Example usage for org.antlr.v4.runtime Token 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.providers.contextproviders.DefinitionContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext context) {
    List<CompletionItem> completionItems = new ArrayList<>();
    List<Integer> lhsDefaultTokens = context.get(CompletionKeys.LHS_TOKENS_KEY).stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL).map(CommonToken::getType)
            .collect(Collectors.toList());

    if (lhsDefaultTokens.contains(BallerinaParser.FUNCTION)) {
        // proxy to function definition context
        return this.getProvider(BallerinaParser.FunctionDefinitionContext.class).getCompletions(context);
    }//from   ww w. j  a v a2 s  .  co m
    switch (lhsDefaultTokens.get(0)) {
    case BallerinaParser.PUBLIC:
        completionItems.addAll(this.getItemsAfterPublic(context));
        break;
    case BallerinaParser.FINAL:
    case BallerinaParser.CONST:
        completionItems.addAll(this.getTypesAndPackages(context));
        break;
    default:
        break;
    }
    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.FunctionDefinitionContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext context) {
    List<CompletionItem> completionItems = new ArrayList<>();
    List<CommonToken> lhsDefaultTokens = context.get(CompletionKeys.LHS_TOKENS_KEY).stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());

    if (!lhsDefaultTokens.isEmpty() && lhsDefaultTokens.get(0).getType() == BallerinaParser.FUNCTION) {
        if (CommonUtil.getLastItem(lhsDefaultTokens).getType() == BallerinaParser.DOT
                || (lhsDefaultTokens.size() > 3 && lhsDefaultTokens.get(lhsDefaultTokens.size() - 2)
                        .getType() == BallerinaParser.DOT)) {
            /*/* w w  w .j  a  va  2s  .c  o m*/
            Consider the following case
            Eg: function x.
            function x.y
             */
            return this.getObjectAttachedFunctions(context, lhsDefaultTokens);
        }
        /*
        Consider the following cases
        Eg: function 
        function x
        and exclude the 
         */
        return context.get(CompletionKeys.VISIBLE_SYMBOLS_KEY).stream()
                .filter(symbolInfo -> symbolInfo.getScopeEntry().symbol instanceof BObjectTypeSymbol)
                .map(symbolInfo -> {
                    BSymbol symbol = symbolInfo.getScopeEntry().symbol;
                    String symbolName = symbol.getName().getValue();
                    CompletionItem item = BTypeCompletionItemBuilder.build((BTypeSymbol) symbol, symbolName);
                    item.setInsertText(symbolName + ".");
                    return item;
                }).collect(Collectors.toList());
    }
    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.GlobalVarDefContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext ctx) {
    ArrayList<CompletionItem> completionItems = new ArrayList<>();
    List<CommonToken> lhsDefaultTokens = ctx.get(CompletionKeys.LHS_TOKENS_KEY).stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    Optional<CommonToken> assignToken = lhsDefaultTokens.stream()
            .filter(commonToken -> commonToken.getType() == BallerinaParser.ASSIGN).findAny();

    if (lhsDefaultTokens.isEmpty()) {
        return completionItems;
    }//from   ww  w. jav  a  2  s . c  o m

    int firstToken = lhsDefaultTokens.get(0).getType();
    int lastToken = CommonUtil.getLastItem(lhsDefaultTokens).getType();
    Optional<CommonToken> listenerKWToken = lhsDefaultTokens.stream()
            .filter(commonToken -> commonToken.getType() == BallerinaParser.LISTENER).findAny();

    if (lhsDefaultTokens.size() >= 2 && BallerinaParser.TYPE_MAP == lhsDefaultTokens.get(0).getType()
            && BallerinaParser.LT == lhsDefaultTokens.get(1).getType()) {
        if (BallerinaParser.GT != CommonUtil.getLastItem(lhsDefaultTokens).getType()) {
            completionItems.addAll(getBasicTypes(ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY)));
        }
    } else if (lhsDefaultTokens.size() <= 2) {
        if (listenerKWToken.isPresent()) {
            completionItems.addAll(this.getListenersAndPackages(ctx));
        } else if (firstToken == BallerinaParser.FINAL) {
            completionItems.addAll(this.getBasicTypes(ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY)));
            completionItems.addAll(this.getPackagesCompletionItems(ctx));
        } else if (this.isInvocationOrInteractionOrFieldAccess(ctx) && BallerinaParser.COLON == lastToken) {
            Either<List<CompletionItem>, List<SymbolInfo>> pkgContent = SymbolFilters
                    .get(DelimiterBasedContentFilter.class).filterItems(ctx);
            completionItems.addAll(this.getCompletionItemList(pkgContent, ctx));
        } else {
            completionItems.addAll(this.getAllTopLevelItems(ctx));
            completionItems.addAll(this.getPackagesCompletionItems(ctx));
        }
    } else if (this.isInvocationOrInteractionOrFieldAccess(ctx)) {
        if (listenerKWToken.isPresent()) {
            int pkgDelimiterIndex = lhsDefaultTokens.stream().map(CommonToken::getType)
                    .collect(Collectors.toList()).indexOf(BallerinaParser.COLON);
            String pkgAlias = lhsDefaultTokens.get(pkgDelimiterIndex - 1).getText();
            completionItems.addAll(this.getListenersFromPackage(ctx, pkgAlias));
        } else {
            Either<List<CompletionItem>, List<SymbolInfo>> filteredList = SymbolFilters
                    .get(DelimiterBasedContentFilter.class).filterItems(ctx);
            completionItems.addAll(this.getCompletionItemList(filteredList, ctx));
        }
        // TODO: usage of index
    } else if (assignToken.isPresent()) {
        completionItems.addAll(this.getVarDefExpressionCompletions(ctx));
    } else {
        completionItems.addAll(this.getAllTopLevelItems(ctx));
        completionItems.addAll(this.getPackagesCompletionItems(ctx));
    }
    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.ImportDeclarationContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext ctx) {
    ArrayList<CompletionItem> completionItems = new ArrayList<>();
    List<BallerinaPackage> packagesList = new ArrayList<>();
    Stream.of(LSPackageLoader.getSdkPackages(), LSPackageLoader.getHomeRepoPackages())
            .forEach(packagesList::addAll);
    List<CommonToken> lhsTokens = ctx.get(CompletionKeys.LHS_TOKENS_KEY);
    List<CommonToken> lhsDefaultTokens = lhsTokens.stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    List<Integer> lhsDefaultTokenTypes = lhsDefaultTokens.stream().map(CommonToken::getType)
            .collect(Collectors.toList());
    int divIndex = lhsDefaultTokenTypes.indexOf(BallerinaParser.DIV);
    int importTokenIndex = lhsDefaultTokenTypes.indexOf(BallerinaParser.IMPORT);
    CommonToken lastToken = CommonUtil.getLastItem(lhsTokens);

    if (divIndex > -1
            && (divIndex == lhsDefaultTokenTypes.size() - 1 || divIndex == lhsDefaultTokenTypes.size() - 2)) {
        String orgName = lhsDefaultTokens.get(lhsDefaultTokenTypes.indexOf(BallerinaParser.DIV) - 1).getText();
        completionItems.addAll(this.getPackageNameCompletions(orgName, packagesList));
    } else if (importTokenIndex > -1 && (importTokenIndex == lhsDefaultTokenTypes.size() - 1
            || importTokenIndex == lhsDefaultTokenTypes.size() - 2)) {
        completionItems.addAll(this.getItemsIncludingOrgName(packagesList));
    } else if (importTokenIndex > -1 && lhsDefaultTokenTypes.size() >= 2
            && (lastToken.getChannel() == Token.HIDDEN_CHANNEL
                    || lhsTokens.get(lhsTokens.size() - 2).getChannel() == Token.HIDDEN_CHANNEL)) {
        completionItems.add(getAsKeyword());
    }/*w  w  w  .ja v a 2  s. c o  m*/

    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.MatchStatementContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext ctx) {
    ArrayList<CompletionItem> completionItems = new ArrayList<>();
    List<CommonToken> lhsTokens = ctx.get(CompletionKeys.LHS_TOKENS_KEY).stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    List<SymbolInfo> symbolInfoList = ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY);
    if (isInvocationOrInteractionOrFieldAccess(ctx)) {
        String delimiter = "";
        String variableName = "";
        for (int i = 0; i < lhsTokens.size(); i++) {
            if (lhsTokens.get(i).getType() == BallerinaParser.DOT
                    || lhsTokens.get(i).getType() == BallerinaParser.COLON
                    || lhsTokens.get(i).getType() == BallerinaParser.RARROW) {
                delimiter = lhsTokens.get(i).getText();
                variableName = lhsTokens.get(i - 1).getText();
                break;
            }/*from ww w. j  ava  2s  .  co  m*/
        }
        List<SymbolInfo> filteredList = FilterUtils.getInvocationAndFieldSymbolsOnVar(ctx, variableName,
                delimiter, ctx.get(CompletionKeys.VISIBLE_SYMBOLS_KEY), false);
        filteredList.removeIf(CommonUtil.invalidSymbolsPredicate());
        filteredList.forEach(symbolInfo -> {
            if (CommonUtil.isValidInvokableSymbol(symbolInfo.getScopeEntry().symbol)) {
                BSymbol scopeEntrySymbol = symbolInfo.getScopeEntry().symbol;
                completionItems.add(this.fillInvokableSymbolMatchSnippet((BInvokableSymbol) scopeEntrySymbol));
            }
        });
    } else {
        symbolInfoList.removeIf(CommonUtil.invalidSymbolsPredicate());
        symbolInfoList.forEach(symbolInfo -> {
            BSymbol bSymbol = symbolInfo.getScopeEntry().symbol;
            if (CommonUtil.isValidInvokableSymbol(symbolInfo.getScopeEntry().symbol)
                    && ((bSymbol.flags & Flags.ATTACHED) != Flags.ATTACHED)) {
                completionItems.add(this.fillInvokableSymbolMatchSnippet((BInvokableSymbol) bSymbol));
            } else if (!(symbolInfo.getScopeEntry().symbol instanceof BInvokableSymbol)
                    && bSymbol instanceof BVarSymbol) {
                fillVarSymbolMatchSnippet((BVarSymbol) bSymbol, completionItems);
                String typeName = symbolInfo.getScopeEntry().symbol.type.toString();
                completionItems.add(BVariableCompletionItemBuilder.build((BVarSymbol) bSymbol,
                        symbolInfo.getSymbolName(), typeName));
            } else if (bSymbol instanceof BPackageSymbol) {
                completionItems.add(
                        BTypeCompletionItemBuilder.build((BPackageSymbol) bSymbol, symbolInfo.getSymbolName()));
            }
        });
    }
    ItemSorters.get(MatchContextItemSorter.class).sortItems(ctx, completionItems);

    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.NamespaceDeclarationContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext ctx) {
    ArrayList<CompletionItem> completionItems = new ArrayList<>();
    List<CommonToken> lhsTokens = ctx.get(CompletionKeys.LHS_TOKENS_KEY);
    List<CommonToken> lhsDefaultTokens = lhsTokens.stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    List<Integer> lhsDefaultTokenTypes = lhsDefaultTokens.stream().map(CommonToken::getType)
            .collect(Collectors.toList());

    if (lhsDefaultTokens.size() >= 2 && !lhsDefaultTokenTypes.contains(BallerinaParser.AS)) {
        completionItems.add(getAsKeyword());
    }//from  ww  w  .j ava  2s. co  m

    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.ServiceDefinitionContextProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext context) {
    List<CompletionItem> completionItems = new ArrayList<>();
    List<CommonToken> lhsTokens = context.get(CompletionKeys.LHS_TOKENS_KEY);
    List<CommonToken> lhsDefaultTokens = lhsTokens.stream()
            .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
            .collect(Collectors.toList());
    int startIndex = lhsDefaultTokens.size() - 1;
    // Backtrack the tokens from the head of the popped tokens in order determine the cursor position
    tokenScanner: while (true) {
        if (startIndex < 0) {
            return completionItems;
        }//w w  w  .ja va2s .c om
        CommonToken token = lhsDefaultTokens.get(startIndex);
        int tokenType = token.getType();
        switch (tokenType) {
        case BallerinaParser.SERVICE:
        case BallerinaParser.ON:
        case BallerinaParser.NEW:
        case BallerinaParser.COLON:
            break tokenScanner;
        default:
            break;
        }

        startIndex--;
    }

    switch (lhsDefaultTokens.get(startIndex).getType()) {
    case BallerinaParser.ON: {
        // suggest all the visible, defined listeners
        completionItems.addAll(this.getCompletionItemsAfterOnKeyword(context));
        break;
    }
    case BallerinaParser.NEW: {
        List<SymbolInfo> filteredSymbols = this
                .filterListenerTypes(context.get(CompletionKeys.VISIBLE_SYMBOLS_KEY));
        completionItems.addAll(this.getCompletionItemList(filteredSymbols, context));
        completionItems.addAll(this.getPackagesCompletionItems(context));
        break;
    }
    case BallerinaParser.COLON: {
        Either<List<CompletionItem>, List<SymbolInfo>> eitherList = SymbolFilters
                .get(DelimiterBasedContentFilter.class).filterItems(context);
        completionItems.addAll(this.getCompletionItemList(eitherList, context));
        break;
    }
    default: {
        // Fill the on keyword completion item
        completionItems.add(Snippet.KW_ON.get().build(context));
        break;
    }
    }
    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.contextproviders.WorkerDeclarationContextProvider.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
public List<CompletionItem> getCompletions(LSContext context) {
    ArrayList<CompletionItem> completionItems = new ArrayList<>();
    List<SymbolInfo> visibleSymbols = context.get(CompletionKeys.VISIBLE_SYMBOLS_KEY);
    Boolean inWorkerReturnCtx = context.get(CompletionKeys.IN_WORKER_RETURN_CONTEXT_KEY);

    if (this.isInvocationOrInteractionOrFieldAccess(context)) {
        List<CommonToken> defaultTokens = context.get(CompletionKeys.LHS_TOKENS_KEY).stream()
                .filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
                .collect(Collectors.toList());
        List<Integer> defaultTokenTypes = defaultTokens.stream().map(CommonToken::getType)
                .collect(Collectors.toList());
        int pkgDelimIndex = defaultTokenTypes.indexOf(BallerinaParser.COLON);
        if (pkgDelimIndex > -1) {
            String pkgName = defaultTokens.get(pkgDelimIndex - 1).getText();
            completionItems.addAll(this.getTypesInPackage(visibleSymbols, pkgName, context));
        }/*from   www  .  j a v  a 2s. c  o  m*/
    } else if (inWorkerReturnCtx != null && inWorkerReturnCtx) {
        completionItems.addAll(this.getBasicTypes(visibleSymbols));
        completionItems.addAll(this.getPackagesCompletionItems(context));
    } else {
        completionItems.add(SnippetGenerator.getReturnsKeywordSnippet().build(context));
    }

    return completionItems;
}

---

From source file:org.ballerinalang.langserver.completions.providers.scopeproviders.BlockStatementScopeProvider.java

License:Open Source License

@Override
public Optional<LSCompletionProvider> getContextProvider(LSContext ctx) {
    List<CommonToken> lhsTokens = ctx.get(CompletionKeys.LHS_TOKENS_KEY);
    if (ctx.get(CompletionKeys.IN_INVOCATION_PARAM_CONTEXT_KEY) != null
            && ctx.get(CompletionKeys.IN_INVOCATION_PARAM_CONTEXT_KEY)) {
        return Optional.ofNullable(this.getProvider(InvocationArgsContextProvider.class));
    }/*from   w ww  . j  a va  2 s . c  o  m*/
    if (lhsTokens == null || lhsTokens.isEmpty()) {
        // Within the block statement and no syntax error
        return Optional.ofNullable(this.getProvider(StatementContextProvider.class));
    }
    int lastLHSTokenIndex = -1;

    for (int i = lhsTokens.size() - 1; i >= 0; i--) {
        if (lhsTokens.get(i).getChannel() == Token.DEFAULT_CHANNEL) {
            lastLHSTokenIndex = i;
            break;
        }
    }

    if (lastLHSTokenIndex == -1) {
        return Optional.empty();
    }
    /*
    Statement context, since the assign token has been handled from the previous condition
     */
    return Optional.ofNullable(this.getProvider(StatementContextProvider.class));
}

---

From source file:org.ballerinalang.langserver.completions.providers.scopeproviders.ObjectTypeNodeScopeProvider.java

License:Open Source License

@Override
public List<CompletionItem> getCompletions(LSContext context) {
    ArrayList<CompletionItem> completionItems = new ArrayList<>();
    BLangNode objectNode = context.get(CompletionKeys.SCOPE_NODE_KEY);

    if (!objectNode.getKind().equals(NodeKind.OBJECT_TYPE)) {
        return completionItems;
    }/* w  w w  .ja v a2  s . c  o m*/

    List<CommonToken> lhsTokens = context.get(CompletionKeys.LHS_TOKENS_KEY);
    List<CommonToken> lhsDefaultTokens = lhsTokens == null ? new ArrayList<>()
            : lhsTokens.stream().filter(commonToken -> commonToken.getChannel() == Token.DEFAULT_CHANNEL)
                    .collect(Collectors.toList());

    if (!lhsDefaultTokens.isEmpty() && lhsDefaultTokens.get(0).getType() == BallerinaParser.MUL) {
        this.fillObjectReferences(completionItems, lhsDefaultTokens, context);
    } else if (this.isInvocationOrInteractionOrFieldAccess(context)) {
        Either<List<CompletionItem>, List<SymbolInfo>> eitherList = SymbolFilters
                .get(DelimiterBasedContentFilter.class).filterItems(context);
        completionItems.addAll(this.getCompletionItemList(eitherList, context));
    } else {
        fillTypes(context, completionItems);
        completionItems.add(Snippet.DEF_FUNCTION_SIGNATURE.get().build(context));
        completionItems.add(Snippet.DEF_FUNCTION.get().build(context));
        completionItems.add(Snippet.DEF_NEW_OBJECT_INITIALIZER.get().build(context));
    }

    return completionItems;
}

---

• «
• 1
• 2
• 3
• 4
• »