Example usage for org.antlr.v4.runtime ParserRuleContext toString

Introduction

In this page you can find the example usage for org.antlr.v4.runtime ParserRuleContext toString.

Prototype

public final String toString(Recognizer<?, ?> recog) 

Source Link

Usage

From source file:org.tvl.goworks.editor.go.semantics.SemanticAnalyzerListener.java

License:Open Source License

@RuleDependency(recognizer = GoParser.class, rule = GoParser.RULE_packageName, version = 0)
private boolean resolveQualifiedIdentifier(TerminalNode node, PackageModel currentPackage,
        Map<String, Collection<PackageModel>> resolvedPackages) {
    Token token = node.getSymbol();/*from  w  w  w . j a  v a2s  .co  m*/
    if (treeDecorator.getProperty(node, GoAnnotations.NODE_TYPE) != NodeType.UNDEFINED) {
        // already resolved
        return false;
    }

    ParserRuleContext qualifier = treeDecorator.getProperty(node, GoAnnotations.QUALIFIER);
    if (qualifier == null) {
        // don't have the information necessary to resolve
        return false;
    }

    Collection<? extends CodeElementModel> resolvedQualifier = treeDecorator.getProperty(qualifier,
            GoAnnotations.MODELS);
    if (resolvedQualifier == null) {
        CodeElementReference qualifierCodeClass = treeDecorator.getProperty(qualifier,
                GoAnnotations.CODE_CLASS);
        assert qualifierCodeClass != null;
        if (qualifierCodeClass != CodeElementReference.MISSING) {
            resolvedQualifier = qualifierCodeClass.resolve(annotatedParseTree, currentPackage,
                    resolvedPackages);
        }
    }

    if (resolvedQualifier == null) {
        CodeElementReference qualifierExprType = treeDecorator.getProperty(qualifier, GoAnnotations.EXPR_TYPE);
        assert qualifierExprType != null;
        if (qualifierExprType != CodeElementReference.MISSING) {
            resolvedQualifier = qualifierExprType.resolve(annotatedParseTree, currentPackage, resolvedPackages);
        }
    }

    if (resolvedQualifier == null) {
        NodeType qualifierNodeType = treeDecorator.getProperty(qualifier, GoAnnotations.NODE_TYPE);
        if (qualifierNodeType == NodeType.UNDEFINED) {
            if (treeDecorator.getProperty(qualifier, GoAnnotations.QUALIFIED_EXPR)) {
                // haven't resolved the qualifier, which is itself a qualified expression
                return false;
            }

            TerminalNode unqualifiedLink = treeDecorator.getProperty(qualifier, GoAnnotations.UNQUALIFIED_LINK);
            if (unqualifiedLink != null) {
                Map<? extends ObjectProperty<?>, ?> properties = treeDecorator.getProperties(unqualifiedLink);
                treeDecorator.putProperties(qualifier, properties);
                qualifierNodeType = treeDecorator.getProperty(qualifier, GoAnnotations.NODE_TYPE);
                if (qualifierNodeType == NodeType.UNDEFINED) {
                    treeDecorator.putProperty(qualifier, GoAnnotations.NODE_TYPE, NodeType.UNKNOWN);
                    qualifierNodeType = NodeType.UNKNOWN;
                }
            } else {
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING, "Unable to resolve unqualified link from qualifier: {0}",
                            qualifier.toString(Arrays.asList(GoParser.ruleNames)));
                }

                qualifierNodeType = NodeType.UNKNOWN;
            }
        }

        assert qualifierNodeType != NodeType.UNDEFINED;

        if (qualifierNodeType == NodeType.UNKNOWN) {
            // can't resolve a dereference if the qualifier couldn't be resolved
            treeDecorator.putProperty(node, GoAnnotations.NODE_TYPE, NodeType.UNKNOWN);
            return true;
        }

        if (qualifierNodeType == NodeType.TYPE_LITERAL) {
            return resolveQualifierType(qualifier, currentPackage, resolvedPackages);
        } else if (qualifierNodeType == NodeType.PACKAGE_REF) {
            assert qualifier instanceof PackageNameContext;
            String packageName = ((PackageNameContext) qualifier).IDENTIFIER().getSymbol().getText();
            resolvedQualifier = resolvedPackages.get(packageName);
            if (resolvedQualifier == null) {
                resolvedQualifier = Collections.emptyList();
            }
        } else if (qualifierNodeType == NodeType.VAR_REF) {
            // must be referring to something within the current file since it's resolved internally
            TerminalNode target = treeDecorator.getProperty(qualifier, GoAnnotations.LOCAL_TARGET);
            assert target != null
                    && treeDecorator.getProperty(target, GoAnnotations.NODE_TYPE) == NodeType.VAR_DECL;
            ParserRuleContext explicitType = treeDecorator.getProperty(qualifier, GoAnnotations.EXPLICIT_TYPE);
            if (explicitType == null && target != null) {
                explicitType = treeDecorator.getProperty(target, GoAnnotations.EXPLICIT_TYPE);
            }

            if (explicitType != null) {
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING, "Unable to resolve explicit type for qualifier: {0}",
                            qualifier.toString(Arrays.asList(GoParser.ruleNames)));
                }

                resolvedQualifier = Collections.emptyList();
            } else {
                ParserRuleContext implicitType = target != null
                        ? treeDecorator.getProperty(target, GoAnnotations.IMPLICIT_TYPE)
                        : null;
                int implicitIndex = target != null
                        ? treeDecorator.getProperty(target, GoAnnotations.IMPLICIT_INDEX)
                        : -1;
                if (LOGGER.isLoggable(Level.WARNING)) {
                    LOGGER.log(Level.WARNING, "Unable to resolve implicit type for qualifier: {0}",
                            qualifier.toString(Arrays.asList(GoParser.ruleNames)));
                }

                resolvedQualifier = Collections.emptyList();
            }
        } else {
            if (LOGGER.isLoggable(Level.WARNING)) {
                LOGGER.log(Level.WARNING, "Unable to resolve qualifier: {0}",
                        qualifier.toString(Arrays.asList(GoParser.ruleNames)));
            }

            resolvedQualifier = Collections.emptyList();
        }
    }

    assert resolvedQualifier != null;
    if (resolvedQualifier == null) {
        LOGGER.log(Level.WARNING, "Should not have a null resolved qualifier at this point.");
        resolvedQualifier = Collections.emptyList();
    }

    String nameText = token.getText();
    List<CodeElementModel> qualifiedModels = new ArrayList<>();
    for (CodeElementModel model : resolvedQualifier) {
        qualifiedModels.addAll(SemanticAnalyzer.getSelectableMembers(model, nameText));
    }

    if (qualifiedModels.isEmpty()) {
        treeDecorator.putProperty(node, GoAnnotations.NODE_TYPE, NodeType.UNKNOWN);
        return true;
    }

    setNodeType(node, qualifiedModels.get(0));
    treeDecorator.putProperty(node, GoAnnotations.RESOLVED, true);
    treeDecorator.putProperty(node, GoAnnotations.MODELS, qualifiedModels);
    return true;
}

---