Example usage for org.antlr.v4.runtime Token DEFAULT_CHANNEL

List of usage examples for org.antlr.v4.runtime Token DEFAULT_CHANNEL

  1. HOME
  2. Java
  3. org.antlr
  4. org.antlr.v4.runtime.*
  5. Token
  6. DEFAULT_CHANNEL

Introduction

In this page you can find the example usage for org.antlr.v4.runtime Token DEFAULT_CHANNEL.

Prototype

int DEFAULT_CHANNEL

To view the source code for org.antlr.v4.runtime Token DEFAULT_CHANNEL.

Click Source Link

Document

All tokens go to the parser (unless skip() is called in that rule) on a particular "channel".

Usage

From source file:org.ballerinalang.langserver.completions.spi.LSCompletionProvider.java

License:Open Source License

/**
 * Check whether the token stream corresponds to a action invocation or a function invocation.
 *
 * @param context Completion operation context
 * @return {@link Boolean}      Whether invocation or Field Access
 *//*from   w  ww. j  av a  2  s  .c om*/
protected boolean isInvocationOrInteractionOrFieldAccess(LSContext context) {
    List<CommonToken> lhsTokens = context.get(CompletionKeys.LHS_TOKENS_KEY);
    if (lhsTokens == null) {
        return false;
    }
    List<CommonToken> lhsDefaultTokens = lhsTokens.stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    return !lhsDefaultTokens.isEmpty() && ((CommonUtil.getLastItem(lhsDefaultTokens)
            .getType() == BallerinaParser.COLON)
            || (CommonUtil.getLastItem(lhsDefaultTokens).getType() == BallerinaParser.DOT)
            || (CommonUtil.getLastItem(lhsDefaultTokens).getType() == BallerinaParser.RARROW)
            || (CommonUtil.getLastItem(lhsDefaultTokens).getType() == BallerinaParser.LARROW)
            || (CommonUtil.getLastItem(lhsDefaultTokens).getType() == BallerinaParser.NOT)
            || (lhsDefaultTokens.size() >= 2
                    && (lhsDefaultTokens.get(lhsDefaultTokens.size() - 2).getType() == BallerinaParser.COLON
                            || lhsDefaultTokens.get(lhsDefaultTokens.size() - 2)
                                    .getType() == BallerinaParser.DOT
                            || lhsDefaultTokens.get(lhsDefaultTokens.size() - 2)
                                    .getType() == BallerinaParser.RARROW
                            || lhsDefaultTokens.get(lhsDefaultTokens.size() - 2)
                                    .getType() == BallerinaParser.LARROW
                            || lhsDefaultTokens.get(lhsDefaultTokens.size() - 2)
                                    .getType() == BallerinaParser.NOT)));
}

From source file:org.ballerinalang.langserver.completions.TreeVisitor.java

License:Open Source License

/**
 * Check whether the cursor resides within the given node type's parameter context.
 * Node name is used to identify the correct node
 * /* ww  w . j a  v a  2  s  .c  o m*/
 * @param nodeName              Name of the node
 * @param nodeType              Node type (Function, Resource, Action or Connector)
 * @return {@link Boolean}      Whether the cursor is within the parameter context
 */
private boolean isWithinParameterContext(String nodeName, String nodeType, SymbolEnv env) {
    ParserRuleContext parserRuleContext = lsContext.get(CompletionKeys.PARSER_RULE_CONTEXT_KEY);
    TokenStream tokenStream = lsContext.get(CompletionKeys.TOKEN_STREAM_KEY);
    String terminalToken = "";

    // If the parser rule context is not parameter context or parameter list context, we skipp the calculation
    if (!(parserRuleContext instanceof BallerinaParser.ParameterContext
            || parserRuleContext instanceof BallerinaParser.ParameterListContext)) {
        return false;
    }

    int startTokenIndex = parserRuleContext.getStart().getTokenIndex();
    ArrayList<String> terminalKeywords = new ArrayList<>(
            Arrays.asList(UtilSymbolKeys.ACTION_KEYWORD_KEY, UtilSymbolKeys.CONNECTOR_KEYWORD_KEY,
                    UtilSymbolKeys.FUNCTION_KEYWORD_KEY, UtilSymbolKeys.RESOURCE_KEYWORD_KEY));
    ArrayList<Token> filteredTokens = new ArrayList<>();
    Token openBracket = null;
    boolean isWithinParams = false;

    // Find the index of the closing bracket
    while (true) {
        if (startTokenIndex > tokenStream.size()) {
            // In the ideal case, should not reach this point
            startTokenIndex = -1;
            break;
        }
        Token token = tokenStream.get(startTokenIndex);
        String tokenString = token.getText();
        if (tokenString.equals(")")) {
            break;
        }
        startTokenIndex++;
    }

    // Backtrack the token stream to find a terminal token
    while (true) {
        if (startTokenIndex < 0) {
            break;
        }
        Token token = tokenStream.get(startTokenIndex);
        String tokenString = token.getText();
        if (terminalKeywords.contains(tokenString)) {
            terminalToken = tokenString;
            break;
        }
        if (token.getChannel() == Token.DEFAULT_CHANNEL) {
            filteredTokens.add(token);
        }
        startTokenIndex--;
    }

    Collections.reverse(filteredTokens);

    /*
    This particular logic identifies a matching pair of closing and opening bracket and then check whether the
    cursor is within those bracket pair
     */
    if (nodeName.equals(filteredTokens.get(0).getText()) && terminalToken.equals(nodeType)) {
        String tokenText;
        for (Token token : filteredTokens) {
            tokenText = token.getText();
            if (tokenText.equals("(")) {
                openBracket = token;
            } else if (tokenText.equals(")") && openBracket != null) {
                Position cursorPos = lsContext.get(DocumentServiceKeys.POSITION_KEY).getPosition();
                int openBLine = openBracket.getLine() - 1;
                int openBCol = openBracket.getCharPositionInLine();
                int closeBLine = token.getLine() - 1;
                int closeBCol = token.getCharPositionInLine();
                int cursorLine = cursorPos.getLine();
                int cursorCol = cursorPos.getCharacter();

                isWithinParams = (cursorLine > openBLine && cursorLine < closeBLine)
                        || (cursorLine == openBLine && cursorCol > openBCol && cursorLine < closeBLine)
                        || (cursorLine > openBLine && cursorCol < closeBCol && cursorLine == closeBLine)
                        || (cursorLine == openBLine && cursorLine == closeBLine && cursorCol >= openBCol
                                && cursorCol <= closeBCol);
                if (isWithinParams) {
                    break;
                } else {
                    openBracket = null;
                }
            }
        }
    }

    if (isWithinParams) {
        this.populateSymbols(this.resolveAllVisibleSymbols(env), env);
        forceTerminateVisitor();
    }

    return isWithinParams;
}

From source file:org.ballerinalang.langserver.completions.util.CompletionVisitorUtil.java

License:Open Source License

/**
 * Check whether the cursor resides within the given node type's parameter context.
 * Node name is used to identify the correct node
 *
 * @param nodeName              Name of the node
 * @param nodeType              Node type (Function, Resource, Action or Connector)
 * @param env                   Symbol Environment
 * @param lsContext             Language Server Operation Context
 * @param treeVisitor           Completion tree visitor instance
 * @return {@link Boolean}      Whether the cursor is within the parameter context
 *///from   w w  w .  j ava 2s . co m
public static boolean isWithinParameterContext(String nodeName, String nodeType, SymbolEnv env,
        LSContext lsContext, TreeVisitor treeVisitor) {
    ParserRuleContext parserRuleContext = lsContext.get(CompletionKeys.PARSER_RULE_CONTEXT_KEY);
    TokenStream tokenStream = lsContext.get(CompletionKeys.TOKEN_STREAM_KEY);
    String terminalToken = "";

    // If the parser rule context is not parameter context or parameter list context, we skipp the calculation
    if (!(parserRuleContext instanceof BallerinaParser.ParameterContext
            || parserRuleContext instanceof BallerinaParser.ParameterListContext)) {
        return false;
    }

    int startTokenIndex = parserRuleContext.getStart().getTokenIndex();
    ArrayList<String> terminalKeywords = new ArrayList<>(
            Arrays.asList(UtilSymbolKeys.ACTION_KEYWORD_KEY, UtilSymbolKeys.CONNECTOR_KEYWORD_KEY,
                    UtilSymbolKeys.FUNCTION_KEYWORD_KEY, UtilSymbolKeys.RESOURCE_KEYWORD_KEY));
    ArrayList<Token> filteredTokens = new ArrayList<>();
    Token openBracket = null;
    boolean isWithinParams = false;

    // Find the index of the closing bracket
    while (true) {
        if (startTokenIndex > tokenStream.size()) {
            // In the ideal case, should not reach this point
            startTokenIndex = -1;
            break;
        }
        Token token = tokenStream.get(startTokenIndex);
        String tokenString = token.getText();
        if (tokenString.equals(")")) {
            break;
        }
        startTokenIndex++;
    }

    // Backtrack the token stream to find a terminal token
    while (true) {
        if (startTokenIndex < 0) {
            break;
        }
        Token token = tokenStream.get(startTokenIndex);
        String tokenString = token.getText();
        if (terminalKeywords.contains(tokenString)) {
            terminalToken = tokenString;
            break;
        }
        if (token.getChannel() == Token.DEFAULT_CHANNEL) {
            filteredTokens.add(token);
        }
        startTokenIndex--;
    }

    Collections.reverse(filteredTokens);

    /*
    This particular logic identifies a matching pair of closing and opening bracket and then check whether the
    cursor is within those bracket pair
     */
    if (nodeName.equals(filteredTokens.get(0).getText()) && terminalToken.equals(nodeType)) {
        String tokenText;
        for (Token token : filteredTokens) {
            tokenText = token.getText();
            if (tokenText.equals("(")) {
                openBracket = token;
            } else if (tokenText.equals(")") && openBracket != null) {
                Position cursorPos = lsContext.get(DocumentServiceKeys.POSITION_KEY).getPosition();
                int openBLine = openBracket.getLine() - 1;
                int openBCol = openBracket.getCharPositionInLine();
                int closeBLine = token.getLine() - 1;
                int closeBCol = token.getCharPositionInLine();
                int cursorLine = cursorPos.getLine();
                int cursorCol = cursorPos.getCharacter();

                isWithinParams = (cursorLine > openBLine && cursorLine < closeBLine)
                        || (cursorLine == openBLine && cursorCol > openBCol && cursorLine < closeBLine)
                        || (cursorLine > openBLine && cursorCol < closeBCol && cursorLine == closeBLine)
                        || (cursorLine == openBLine && cursorLine == closeBLine && cursorCol >= openBCol
                                && cursorCol <= closeBCol);
                if (isWithinParams) {
                    break;
                } else {
                    openBracket = null;
                }
            }
        }
    }

    if (isWithinParams) {
        treeVisitor.populateSymbols(treeVisitor.resolveAllVisibleSymbols(env), env);
        treeVisitor.forceTerminateVisitor();
    }

    return isWithinParams;
}

From source file:org.ballerinalang.langserver.completions.util.filters.ConnectorInitExpressionItemFilter.java

License:Open Source License

/**
 * Get the first non-hidden token from the start index.
 * @param startIndex        Start index/* w  ww .j ava  2s . c  o m*/
 * @param loopIncrementer   decider value used for iterating either left or right from startIndex
 * @param tokenStream       Token Stream
 * @return {@link Token}    Not Hidden Token
 */
private static Token getFirstNonHiddenToken(int startIndex, int loopIncrementer, TokenStream tokenStream) {
    int searchIndex = startIndex + loopIncrementer;
    while (true) {
        if (searchIndex < 0) {
            return null;
        }
        if (tokenStream.get(searchIndex).getChannel() == Token.DEFAULT_CHANNEL) {
            return tokenStream.get(searchIndex);
        }
        searchIndex += loopIncrementer;
    }
}

From source file:org.ballerinalang.langserver.completions.util.filters.DelimiterBasedContentFilter.java

License:Open Source License

@Override
public Either<List<CompletionItem>, List<SymbolInfo>> filterItems(LSContext ctx) {
    List<CommonToken> lhsTokens = ctx.get(CompletionKeys.LHS_TOKENS_KEY);
    List<CommonToken> defaultTokens = lhsTokens.stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    String delimiter = CommonUtil.getLastItem(defaultTokens).getText();
    String symbolToken = defaultTokens.get(defaultTokens.size() - 2).getText();
    ArrayList<SymbolInfo> returnSymbolsInfoList = new ArrayList<>();
    List<SymbolInfo> visibleSymbols = ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY);
    SymbolInfo symbol = FilterUtils.getVariableByName(symbolToken, visibleSymbols);
    boolean isWorkerReceive = UtilSymbolKeys.LEFT_ARROW_SYMBOL_KEY.equals(delimiter);
    boolean isActionInvocation = UtilSymbolKeys.RIGHT_ARROW_SYMBOL_KEY.equals(delimiter)
            && CommonUtil.isClientObject(symbol.getScopeEntry().symbol);
    boolean isWorkerSend = !isActionInvocation && UtilSymbolKeys.RIGHT_ARROW_SYMBOL_KEY.equals(delimiter);

    if (UtilSymbolKeys.DOT_SYMBOL_KEY.equals(delimiter) || UtilSymbolKeys.BANG_SYMBOL_KEY.equals(delimiter)
            || isActionInvocation) {//from  w w w .  ja  v a2  s . co m
        returnSymbolsInfoList.addAll(
                FilterUtils.getInvocationAndFieldSymbolsOnVar(ctx, symbolToken, delimiter, visibleSymbols));
    } else if (isWorkerSend || isWorkerReceive) {
        List<SymbolInfo> filteredList = visibleSymbols.stream()
                .filter(symbolInfo -> symbolInfo.getScopeEntry().symbol.type instanceof BFutureType
                        && ((BFutureType) symbolInfo.getScopeEntry().symbol.type).workerDerivative)
                .collect(Collectors.toList());
        returnSymbolsInfoList.addAll(filteredList);
    } else if (UtilSymbolKeys.PKG_DELIMITER_KEYWORD.equals(delimiter)) {
        // We are filtering the package functions, actions and the types
        Either<List<CompletionItem>, List<SymbolInfo>> filteredList = this.getActionsFunctionsAndTypes(ctx,
                symbolToken, delimiter);
        if (filteredList.isLeft()) {
            return Either.forLeft(filteredList.getLeft());
        }
        returnSymbolsInfoList.addAll(filteredList.getRight());
    }

    return Either.forRight(returnSymbolsInfoList);
}

From source file:org.ballerinalang.langserver.completions.util.filters.PackageActionFunctionAndTypesFilter.java

License:Open Source License

/**
 * Check whether the statement being writing is a connector init by analyzing the tokens.
 * @param startIndex    Search start index
 * @param context       Document service context
 * @return {@link Boolean} connector init or not
 *///from  w  ww. j  a  v  a  2 s.  c  om
private boolean isConnectorInit(int startIndex, TextDocumentServiceContext context) {
    int nonHiddenTokenCount = 0;
    int counter = startIndex - 1;
    TokenStream tokenStream = context.get(DocumentServiceKeys.TOKEN_STREAM_KEY);

    while (true) {
        Token token = tokenStream.get(counter);
        if (nonHiddenTokenCount == 2 && tokenStream.get(counter + 1).getText().equals(CREATE_KEYWORD)) {
            return true;
        } else if (nonHiddenTokenCount == 2) {
            break;
        }

        if (token.getChannel() == Token.DEFAULT_CHANNEL) {
            nonHiddenTokenCount++;
        }
        counter--;
    }

    return false;
}

From source file:org.ballerinalang.langserver.completions.util.filters.PackageActionFunctionAndTypesFilter.java

License:Open Source License

/**
 * Get the package delimiter token index, which is the index of . or :.
 * @param completionContext     Text Document Service context (Completion Context)
 * @return {@link Integer}      Index of the delimiter
 *///from w w w . j  a  v a 2  s.  com
private int getPackageDelimiterTokenIndex(TextDocumentServiceContext completionContext) {
    ArrayList<String> terminalTokens = new ArrayList<>(Arrays.asList(new String[] { ";", "}", "{" }));
    int searchTokenIndex = completionContext.get(DocumentServiceKeys.TOKEN_INDEX_KEY);
    TokenStream tokenStream = completionContext.get(DocumentServiceKeys.TOKEN_STREAM_KEY);
    int delimiterIndex = -1;
    String currentTokenStr = tokenStream.get(searchTokenIndex).getText();

    if (terminalTokens.contains(currentTokenStr)) {
        searchTokenIndex -= 1;
        while (true) {
            if (tokenStream.get(searchTokenIndex).getChannel() == Token.DEFAULT_CHANNEL) {
                break;
            } else {
                searchTokenIndex -= 1;
            }
        }
    }

    while (true) {
        if (searchTokenIndex >= tokenStream.size()) {
            break;
        }
        String tokenString = tokenStream.get(searchTokenIndex).getText();
        if (".".equals(tokenString) || ":".equals(tokenString)) {
            delimiterIndex = searchTokenIndex;
            break;
        } else if (terminalTokens.contains(tokenString)) {
            break;
        } else {
            searchTokenIndex++;
        }
    }

    return delimiterIndex;
}

From source file:org.ballerinalang.langserver.completions.util.sorters.CallableUnitBodyItemSorter.java

License:Open Source License

@Override
public void sortItems(TextDocumentServiceContext ctx, List<CompletionItem> completionItems) {
    BLangNode previousNode = ctx.get(CompletionKeys.PREVIOUS_NODE_KEY);
    TokenStream tokenStream = ctx.get(DocumentServiceKeys.TOKEN_STREAM_KEY);

    if (ctx.get(DocumentServiceKeys.PARSER_RULE_CONTEXT_KEY) != null) {
        int currentTokenStart = ctx.get(DocumentServiceKeys.PARSER_RULE_CONTEXT_KEY).getStart().getTokenIndex();
        Token nextToken = tokenStream.get(currentTokenStart + 1);
        int cursorLine = ctx.get(DocumentServiceKeys.POSITION_KEY).getPosition().getLine();
        int cursorChar = ctx.get(DocumentServiceKeys.POSITION_KEY).getPosition().getCharacter();

        if (nextToken.getChannel() != Token.DEFAULT_CHANNEL && (cursorLine > nextToken.getLine() - 1
                || (cursorLine == nextToken.getLine() - 1 && cursorChar > nextToken.getCharPositionInLine()))) {
            completionItems.clear();/*w w w . j a  va2  s.c  o  m*/
            return;
        }
    }

    this.clearItemsIfWorkerExists(ctx, completionItems);
    if (previousNode == null) {
        this.populateWhenCursorBeforeOrAfterEp(completionItems);
    } else if (previousNode instanceof BLangVariableDef) {
        BType bLangType = ((BLangVariableDef) previousNode).var.type;
        if (bLangType instanceof BEndpointType) {
            this.populateWhenCursorBeforeOrAfterEp(completionItems);
        } else if (ctx.get(CompletionKeys.INVOCATION_STATEMENT_KEY) == null
                || !ctx.get(CompletionKeys.INVOCATION_STATEMENT_KEY)) {
            CompletionItem workerItem = this.getWorkerSnippet();
            workerItem.setSortText(Priority.PRIORITY160.toString());
            completionItems.add(workerItem);
        }
    } else if (previousNode instanceof BLangWorker) {
        completionItems.add(this.getWorkerSnippet());
    }
    this.setPriorities(completionItems);
}

From source file:org.ballerinalang.langserver.sourceprune.AbstractTokenTraverser.java

License:Open Source License

void alterTokenText(Token token) {
    this.removedTokens.add(new CommonToken(token));
    if (token.getType() == BallerinaParser.NEW_LINE || token.getChannel() != Token.DEFAULT_CHANNEL) {
        return;/*from w  ww . ja  v a 2 s.  c om*/
    }
    ((CommonToken) token).setText(getNCharLengthEmptyLine(token.getText().length()));
    this.lastAlteredToken = token.getType();
}

From source file:org.eclipse.titan.designer.AST.ASN1.Block.java

License:Open Source License

@Override
public int getChannel() {
    return Token.DEFAULT_CHANNEL;
}