public Symtab getSymtab() { return Symtab.instance(context); }
public Symtab symtab() { return Symtab.instance(context); }
/** * Refines the receiver of a method invocation to type non-null after successful invocation, and * refines the value of the expression as a whole to non-null if applicable (e.g., if the method * returns a primitive type). * * <p>NOTE: This transfer makes the unsound assumption that fields reachable via the actual params * of this method invocation are not mutated by the callee. To be sound with respect to escaping * mutable references in general, we would have to set to top (i.e. NULLABLE) any tracked access * path that could contain an alias of an actual parameter of this invocation. */ @Override Nullness visitMethodInvocation( MethodInvocationNode node, Updates thenUpdates, Updates elseUpdates, Updates bothUpdates) { ClassAndMethod callee = tryGetMethodSymbol(node.getTree(), Types.instance(context)); if (callee != null && !callee.isStatic) { setNonnullIfTrackable(bothUpdates, node.getTarget().getReceiver()); } setUnconditionalArgumentNullness(bothUpdates, node.getArguments(), callee); setConditionalArgumentNullness( thenUpdates, elseUpdates, node.getArguments(), callee, Types.instance(context), Symtab.instance(context)); return returnValueNullness(node, callee); }
Type ty = ASTHelpers.getType(binaryExpr.getLeftOperand()); Types types = Types.instance(state.context); Symtab symtab = Symtab.instance(state.context);
/** * Creates a new scanner. * * @param logHandler * the handler for reporting messages * @param context * the JSweet transpilation context * @param compilationUnit * the compilation to be scanned */ public AbstractTreeScanner(TranspilationHandler logHandler, JSweetContext context, JCCompilationUnit compilationUnit) { this.logHandler = logHandler; this.context = context; this.context.symtab = Symtab.instance(context); this.context.names = Names.instance(context); this.context.types = Types.instance(context); this.context.modelTypes = com.sun.tools.javac.model.JavacTypes.instance(context); this.setCompilationUnit(compilationUnit); }
/** * Creates a new compilation environment with the given options and * classpath. */ public static JavaCompilationEnvironment create(JSweetOptions jsweetOptions, String classPath) { JSweetContext context = new JSweetContext(jsweetOptions); Options options = Options.instance(context); options.put(Option.CLASSPATH, classPath); options.put(Option.XLINT, "path"); context.put(Log.outKey, new PrintWriter(System.out)); // options.put(Option.XLINT_CUSTOM.text + "-" + // LintCategory.OPTIONS.option, "true"); // options.remove(Option.XLINT_CUSTOM.text + // LintCategory.OPTIONS.option); options.put(Option.XLINT_CUSTOM.text + "-" + LintCategory.OVERRIDES.option, "true"); JavacFileManager.preRegister(context); JavaFileManager fileManager = context.get(JavaFileManager.class); Log log = Log.instance(context); log.emitWarnings = false; log.suppressNotes = true; Types javacTypes = Types.instance(context); JavaCompiler compiler = JavaCompiler.instance(context); compiler.attrParseOnly = true; compiler.verbose = false; compiler.genEndPos = true; compiler.keepComments = true; Names names = Names.instance(context); Symtab symtab = Symtab.instance(context); return new JavaCompilationEnvironment(fileManager, compiler, options, context, log, javacTypes, names, symtab); }
Symbol.ClassSymbol getObjectClass() { Symtab symbols = Symtab.instance( _tp.getContext() ); return (Symbol.ClassSymbol)symbols.objectType.tsym; }
/** * Use a new context. May be called from outside to update * internal state for a new annotation-processing round. * This instance is *not* then registered with the new context. */ public void setContext(Context context) { syms = Symtab.instance(context); types = Types.instance(context); }
@Override public Symbol.ClassSymbol getLoadedClass( Context ctx, String fqn ) { Name name = Names.instance( ctx ).fromString( fqn ); return Symtab.instance( ctx ).classes.get( name ); }
@Override public void started(TaskEvent e) { if (e != null && e.getKind() == TaskEvent.Kind.GENERATE) { JCClassDecl tree = syms2trees.get((ClassSymbol)e.getTypeElement()); if (tree != null) pruneTree(tree, Symtab.instance(jti.getContext()), null); } } @Override
protected Infer(Context context) { context.put(inferKey, this); syms = Symtab.instance(context); types = Types.instance(context); rs = Resolve.instance(context); chk = Check.instance(context); }
private Element getElementByFQN(String fqn) { Elements elements = copy.getElements(); Element element = elements.getTypeElement(fqn); if (element == null) element = elements.getPackageElement(fqn); if (element == null) element = Symtab.instance(copy.impl.getJavacTask().getContext()).enterClass((com.sun.tools.javac.util.Name)elements.getName(fqn)); return element; }
/** * Use a new context. May be called from outside to update * internal state for a new annotation-processing round. */ public void setContext(Context context) { context.put(JavacElements.class, this); javaCompiler = JavaCompiler.instance(context); syms = Symtab.instance(context); names = Names.instance(context); types = Types.instance(context); enter = Enter.instance(context); }
private PostFlowAnalysis(Context ctx) { log = Log.instance(ctx); types = Types.instance(ctx); enter = Enter.instance(ctx); names = Names.instance(ctx); syms = Symtab.instance(ctx); outerThisStack = List.nil(); }
protected Flow(Context context) { context.put(flowKey, this); names = Name.Table.instance(context); log = Log.instance(context); syms = Symtab.instance(context); types = Types.instance(context); chk = Check.instance(context); lint = Lint.instance(context); }
protected Flow(Context context) { context.put(flowKey, this); names = Name.Table.instance(context); log = Log.instance(context); syms = Symtab.instance(context); types = Types.instance(context); chk = Check.instance(context); lint = Lint.instance(context); }
protected TypeAnnotations(Context context) { context.put(typeAnnosKey, this); names = Names.instance(context); log = Log.instance(context); syms = Symtab.instance(context); annotate = Annotate.instance(context); attr = Attr.instance(context); Options options = Options.instance(context); }
protected Types(Context context) { context.put(typesKey, this); syms = Symtab.instance(context); names = Name.Table.instance(context); allowBoxing = Source.instance(context).allowBoxing(); reader = ClassReader.instance(context); source = Source.instance(context); chk = Check.instance(context); capturedName = names.fromString("<captured wildcard>"); } // </editor-fold>
protected Types(Context context) { context.put(typesKey, this); syms = Symtab.instance(context); names = Name.Table.instance(context); allowBoxing = Source.instance(context).allowBoxing(); reader = ClassReader.instance(context); source = Source.instance(context); chk = Check.instance(context); capturedName = names.fromString("<captured wildcard>"); } // </editor-fold>
protected Annotate(Context context) { context.put(annotateKey, this); attr = Attr.instance(context); make = TreeMaker.instance(context); log = Log.instance(context); syms = Symtab.instance(context); names = Names.instance(context); rs = Resolve.instance(context); types = Types.instance(context); cfolder = ConstFold.instance(context); chk = Check.instance(context); }