@Override public void enter(JavaSymbol symbol) { this.orderedSymbols.add(symbol); super.enter(symbol); }
private void enterSymbol(Tree tree, JavaSymbol symbol) { env.scope.enter(symbol); semanticModel.associateSymbol(tree, symbol); }
private void enterBinop(String name, JavaType left, JavaType right, JavaType result) { JavaType type = new MethodJavaType(ImmutableList.of(left, right), result, ImmutableList.<JavaType>of(), methodClass); JavaSymbol symbol = new JavaSymbol.MethodJavaSymbol(Flags.PUBLIC | Flags.STATIC, name, type, predefClass); predefClass.members.enter(symbol); }
private void enterBinop(String name, JavaType left, JavaType right, JavaType result) { JavaType type = new JavaType.MethodJavaType(ImmutableList.of(left, right), result, ImmutableList.<JavaType>of(), methodClass); JavaSymbol symbol = new JavaSymbol.MethodJavaSymbol(Flags.PUBLIC | Flags.STATIC, name, type, predefClass); predefClass.members.enter(symbol); }
private void enterBinop(String name, JavaType left, JavaType right, JavaType result) { JavaType type = new MethodJavaType(ImmutableList.of(left, right), result, ImmutableList.<JavaType>of(), methodClass); JavaSymbol symbol = new JavaSymbol.MethodJavaSymbol(Flags.PUBLIC | Flags.STATIC, name, type, predefClass); predefClass.members.enter(symbol); }
private void enterBinop(String name, JavaType left, JavaType right, JavaType result) { JavaType type = new JavaType.MethodJavaType(ImmutableList.of(left, right), result, ImmutableList.<JavaType>of(), methodClass); JavaSymbol symbol = new JavaSymbol.MethodJavaSymbol(Flags.PUBLIC | Flags.STATIC, name, type, predefClass); predefClass.members.enter(symbol); }
/** * Registers builtin types as symbols, so that they can be found as an usual identifiers. */ private JavaType initType(int tag, String name) { JavaSymbol.TypeJavaSymbol symbol = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, name, rootPackage); symbol.members = new Scope(symbol); predefClass.members.enter(symbol); ((ClassJavaType) symbol.type).interfaces = ImmutableList.of(); symbol.type.tag = tag; return symbol.type; }
/** * Registers builtin types as symbols, so that they can be found as an usual identifiers. */ private JavaType initType(int tag, String name) { JavaSymbol.TypeJavaSymbol symbol = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, name, rootPackage); symbol.members = new Scope(symbol); predefClass.members.enter(symbol); ((ClassJavaType) symbol.type).interfaces = ImmutableList.of(); symbol.type.tag = tag; return symbol.type; }
@Override public void visitFormalTypeParameter(String name) { typeVariableSymbol = new JavaSymbol.TypeVariableJavaSymbol(name, classSymbol); classSymbol.typeParameters.enter(typeVariableSymbol); classSymbol.addTypeParameter((JavaType.TypeVariableJavaType) typeVariableSymbol.type); bounds = Lists.newArrayList(); ((JavaType.TypeVariableJavaType) typeVariableSymbol.type).bounds = bounds; }
@Override public void visitFormalTypeParameter(String name) { typeVariableSymbol = new JavaSymbol.TypeVariableJavaSymbol(name, methodSymbol); methodSymbol.typeParameters.enter(typeVariableSymbol); methodSymbol.addTypeParameter((JavaType.TypeVariableJavaType) typeVariableSymbol.type); bounds = Lists.newArrayList(); ((JavaType.TypeVariableJavaType) typeVariableSymbol.type).bounds = bounds; }
/** * Registers builtin types as symbols, so that they can be found as an usual identifiers. */ private JavaType initType(int tag, String name) { JavaSymbol.TypeJavaSymbol symbol = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, name, rootPackage); symbol.members = new Scope(symbol); predefClass.members.enter(symbol); ((JavaType.ClassJavaType) symbol.type).interfaces = ImmutableList.of(); symbol.type.tag = tag; return symbol.type; }
/** * Registers builtin types as symbols, so that they can be found as an usual identifiers. */ private JavaType initType(int tag, String name) { JavaSymbol.TypeJavaSymbol symbol = new JavaSymbol.TypeJavaSymbol(Flags.PUBLIC, name, rootPackage); symbol.members = new Scope(symbol); predefClass.members.enter(symbol); ((JavaType.ClassJavaType) symbol.type).interfaces = ImmutableList.of(); symbol.type.tag = tag; return symbol.type; }
private void enterSymbol(JavaSymbol symbol, ImportTree tree) { env.namedImports.enter(symbol); //FIXME We add all symbols to named Imports for static methods, but only the first one will be resolved as we don't handle arguments. //FIXME That is why we only add the first symbol so we resolve references at best for now. //add to semantic model only the first symbol. //twice the same import : ignore the duplication JLS8 7.5.1. if (semanticModel.getSymbol(tree) == null) { semanticModel.associateSymbol(tree, symbol); } }
private void enterSymbol(JavaSymbol symbol, ImportTree tree) { env.namedImports.enter(symbol); //FIXME We add all symbols to named Imports for static methods, but only the first one will be resolved as we don't handle arguments. //FIXME That is why we only add the first symbol so we resolve references at best for now. //add to semantic model only the first symbol. //twice the same import : ignore the duplication JLS8 7.5.1. if (semanticModel.getSymbol(tree) == null) { semanticModel.associateSymbol(tree, symbol); } }
/** * Invoked when current class classified as outer class of some inner class. * Adds inner class as member. */ private void defineInnerClass(String bytecodeName, int flags) { JavaSymbol.TypeJavaSymbol innerClass = getClassSymbol(classSymbol, bytecodeName, flags); innerClass.flags |= Flags.filterAccessBytecodeFlags(flags); Preconditions.checkState(innerClass.owner == classSymbol, "Innerclass: " + innerClass.owner.getName() + " and classSymbol: " + classSymbol.getName() + " are not the same."); classSymbol.members.enter(innerClass); }
/** * Invoked when current class classified as outer class of some inner class. * Adds inner class as member. */ private void defineInnerClass(String bytecodeName, int flags) { JavaSymbol.TypeJavaSymbol innerClass = getClassSymbol(classSymbol, bytecodeName, flags); innerClass.flags |= bytecodeCompleter.filterBytecodeFlags(flags); Preconditions.checkState(innerClass.owner == classSymbol, "Innerclass: " + innerClass.owner.getName() + " and classSymbol: " + classSymbol.getName() + " are not the same."); classSymbol.members.enter(innerClass); }
/** * Invoked when current class classified as outer class of some inner class. * Adds inner class as member. */ private void defineInnerClass(String bytecodeName, int flags) { JavaSymbol.TypeJavaSymbol innerClass = getClassSymbol(bytecodeName, flags); innerClass.flags |= bytecodeCompleter.filterBytecodeFlags(flags); Preconditions.checkState(innerClass.owner == classSymbol, "Innerclass: " + innerClass.owner.getName() + " and classSymbol: " + classSymbol.getName() + " are not the same."); classSymbol.members.enter(innerClass); }
/** * Invoked when current class classified as outer class of some inner class. * Adds inner class as member. */ private void defineInnerClass(String bytecodeName, int flags) { JavaSymbol.TypeJavaSymbol innerClass = getClassSymbol(classSymbol, bytecodeName, flags); innerClass.flags |= Flags.filterAccessBytecodeFlags(flags); Preconditions.checkState(innerClass.owner == classSymbol, "Innerclass: " + innerClass.owner.getName() + " and classSymbol: " + classSymbol.getName() + " are not the same."); classSymbol.members.enter(innerClass); }
private void enterSymbol(JavaSymbol symbol, ImportTree tree) { env.namedImports.enter(symbol); //FIXME We add all symbols to named Imports for static methods, but only the first one will be resolved as we don't handle arguments. //FIXME That is why we only add the first symbol so we resolve references at best for now. //add to semantic model only the first symbol. //twice the same import : ignore the duplication JLS8 7.5.1. if (semanticModel.getSymbol(tree) == null && semanticModel.getTree(symbol) == null) { semanticModel.associateSymbol(tree, symbol); } }
private void enterSymbol(JavaSymbol symbol, ImportTree tree) { env.namedImports.enter(symbol); //FIXME We add all symbols to named Imports for static methods, but only the first one will be resolved as we don't handle arguments. //FIXME That is why we only add the first symbol so we resolve references at best for now. //add to semantic model only the first symbol. //twice the same import : ignore the duplication JLS8 7.5.1. if (semanticModel.getSymbol(tree) == null && semanticModel.getTree(symbol) == null) { semanticModel.associateSymbol(tree, symbol); } }