public EnclosingInstanceSymbol(Names names, Symbol curr) { super( Flags.SYNTHETIC, names.fromString(GuardedByExpression.ENCLOSING_INSTANCE_NAME), curr.type, curr); }
public Name getName(String nameStr) { return Names.instance(context).fromString(nameStr); }
private Name getName(String name) { return Names.instance(context).fromString(name); }
public Name asName(CharSequence str) { return names().fromString(str.toString()); }
private <T> NameIndexedMap<T> makeOptimizedLookup( Names names, Set<MethodRef> refs, Function<MethodRef, T> getValForRef) { Map<Name, Map<MethodRef, T>> nameMapping = new LinkedHashMap<>(); for (MethodRef ref : refs) { Name methodName = names.fromString(ref.methodName); Map<MethodRef, T> mapForName = nameMapping.get(methodName); if (mapForName == null) { mapForName = new LinkedHashMap<>(); nameMapping.put(methodName, mapForName); } mapForName.put(ref, getValForRef.apply(ref)); } return new NameIndexedMap<>(nameMapping); }
PlaceholderParamIdent(UVariableDecl param, Context context) { super(Names.instance(context).fromString(param.getName().contents()), null); this.param = checkNotNull(param); } }
/** * Looks up a type element from its qualified name. * * @return null if not found */ public static ClassSymbol getTypeByName(JSweetContext context, String qualifiedName) { return context.symtab.classes.get(context.names.fromString(qualifiedName)); }
/** * Looks up a package element from its qualified name. * * @return null if not found */ public static PackageSymbol getPackageByName(JSweetContext context, String qualifiedName) { return context.symtab.packages.get(context.names.fromString(qualifiedName)); }
public EnclosingInstanceSymbol(Names names, Symbol curr) { super( Flags.SYNTHETIC, names.fromString(GuardedByExpression.ENCLOSING_INSTANCE_NAME), curr.type, curr); }
public VariableTree Variable(ModifiersTree modifiers, CharSequence name, Tree type, ExpressionTree initializer) { return make.at(NOPOS).VarDef((JCModifiers)modifiers, names.fromString(name.toString()), (JCExpression)type, (JCExpression)initializer); }
/** Resolve an identifier which may be the binary name of a class or * the Java name of a class or package. * @param name The name to resolve */ public Symbol resolveBinaryNameOrIdent(String name) { try { Name flatname = names.fromString(name.replace("/", ".")); return reader.loadClass(flatname); } catch (CompletionFailure ignore) { return resolveIdent(name); } }
public boolean alreadyDefinedIn(CharSequence name, ExecutableType method, TypeElement enclClass) { Type.MethodType meth = ((Type)method).asMethodType(); ClassSymbol clazz = (ClassSymbol)enclClass; Scope scope = clazz.members(); Name n = names.fromString(name.toString()); for (Symbol sym : scope.getSymbolsByName(n, Scope.LookupKind.NON_RECURSIVE)) { if(sym.type instanceof ExecutableType && types.isSubsignature(meth, (ExecutableType)sym.type)) return true; } return false; }
public MemberReferenceTree MemberReference(ReferenceMode refMode, CharSequence name, ExpressionTree expression, List<? extends ExpressionTree> typeArguments) { ListBuffer<JCExpression> targs; if (typeArguments != null) { targs = new ListBuffer<JCExpression>(); for (ExpressionTree t : typeArguments) targs.append((JCExpression)t); } else { targs = null; } return make.at(NOPOS).Reference(refMode, names.fromString(name.toString()), (JCExpression) expression, targs != null ? targs.toList() : null); }
public AttributeTree Attribute(CharSequence name, AttributeTree.ValueKind vkind, List<? extends DocTree> value) { ListBuffer<DCTree> lb = null; if(value != null) { lb = new ListBuffer<DCTree>(); for (DocTree t : value) { lb.append((DCTree) t); } } return docMake.at(NOPOS).Attribute((Name) names.fromString(name.toString()), vkind, lb != null ? lb.toList() : null); }
public StartElementTree StartElement(CharSequence name, List<? extends DocTree> attrs, boolean selfClosing) { ListBuffer<DCTree> atr = new ListBuffer<DCTree>(); for (DocTree t : attrs) { atr.append((DCTree) t); } return docMake.at(NOPOS).StartElement(names.fromString(name.toString()), atr.toList(), selfClosing); }
public UnknownBlockTagTree UnknownBlockTag(CharSequence name, List<? extends DocTree> content) { ListBuffer<DCTree> cont = new ListBuffer<DCTree>(); for (DocTree t : content) { cont.append((DCTree) t); } return docMake.at(NOPOS).UnknownBlockTag(names.fromString(name.toString()), cont.toList()); }
public UnknownInlineTagTree UnknownInlineTag(CharSequence name, List<? extends DocTree> content) { ListBuffer<DCTree> cont = new ListBuffer<DCTree>(); for (DocTree t : content) { cont.append((DCTree) t); } return docMake.at(NOPOS).UnknownInlineTag(names.fromString(name.toString()), cont.toList()); }
public TypeParameterTree TypeParameter(CharSequence name, List<? extends ExpressionTree> boundsList) { ListBuffer<JCExpression> bounds = new ListBuffer<JCExpression>(); for (Tree t : boundsList) bounds.append((JCExpression)t); return make.at(NOPOS).TypeParameter(names.fromString(name.toString()), bounds.toList()); }
private VarSymbol addParameter(String name, Type p, boolean genArg) { VarSymbol vsym = new VarSymbol(0, names.fromString(name), p, localContext.bridgeSym); params.append(make.VarDef(vsym, null)); if (genArg) { args.append(make.Ident(vsym)); } return vsym; } }
private Symbol.MethodSymbol findReflectUtilConstructor( JCTree.JCNewClass tree ) { Symtab symtab = _tp.getSymtab(); Type.ArrayType classArrayType = new Type.ArrayType( symtab.classType, symtab.arrayClass ); Type.ArrayType objectArrayType = new Type.ArrayType( symtab.objectType, symtab.arrayClass ); List<Type> paramTypes = List.of( symtab.classType, classArrayType, objectArrayType ); Symbol.ClassSymbol reflectMethodClassSym = IDynamicJdk.instance().getTypeElement( _tp.getContext(), _tp.getCompilationUnit(), ReflectionRuntimeMethods.class.getName() ); Names names = Names.instance( _tp.getContext() ); return resolveMethod( tree.pos(), names.fromString( "construct" ), reflectMethodClassSym.type, paramTypes ); }