public TypeData getTypeData() { if (typeData == null) { typeData = new TypeData(getPackageName(), getSourceName(), getInternalName(), unit.getResourceLocation(), getBytes(), getUnit().getLastModified()); } return typeData; }
/** * Adds new units to an existing TypeOracle. * * @param logger logger to use * @param typeDataList collection of data need to build types */ public void addNewTypes(TreeLogger logger, Collection<TypeData> typeDataList) { addNewTypes(logger, typeDataList, new MethodArgNamesLookup()); }
/** * Intended for unit testing only. * * @return a mocked up version of this mediator's resolver. */ public Resolver getMockResolver() { return new TypeOracleMediatorResolver(new TypeOracleBuildContext(new MethodArgNamesLookup())); }
private boolean resolveParameters(TreeLogger logger, JAbstractMethod method, CollectMethodData methodData, TypeOracleBuildContext context) { Type[] argTypes = methodData.getArgTypes(); boolean argNamesAreReal = methodData.hasActualArgNames(); String[] argNames = methodData.getArgNames(); if (!argNamesAreReal) { String[] lookupNames = context.allMethodArgs.lookup(method, methodData); if (lookupNames != null) { argNames = lookupNames; argNamesAreReal = true; } } List<CollectAnnotationData>[] paramAnnot = methodData.getArgAnnotations(); for (int i = 0; i < argTypes.length; ++i) { JType argType = resolveType(argTypes[i]); if (argType == null) { return false; } // Try to resolve annotations, ignore any that fail. Map<Class<? extends Annotation>, Annotation> declaredAnnotations = new HashMap<Class<? extends Annotation>, Annotation>(); resolveAnnotations(logger, paramAnnot[i], declaredAnnotations); newParameter(method, argType, argNames[i], declaredAnnotations, argNamesAreReal); } return true; }
public TypeOracle getTypeOracle() { return getGeneratorContext().getTypeOracle(); }
public UnifyAst(JProgram program, JsProgram jsProgram, JJSOptions options, RebindPermutationOracle rpo) { this.program = program; this.jsProgram = jsProgram; this.options = options; this.rpo = rpo; this.classFileMap = rpo.getCompilationState().getClassFileMap(); this.classFileMapBySource = rpo.getCompilationState().getClassFileMapBySource(); }
/** * Returns a hash code on the byte code of the class. */ public String getSignatureHash() { if (signatureHash == null) { signatureHash = BytecodeSignatureMaker.getCompileDependencySignature(getBytes()); } return signatureHash; }
/** * Retrieves class definitions from a {@link GeneratorContext} by downcasting. */ private Map<String, CompiledClass> extractClassFileMap() { if (context instanceof StandardGeneratorContext) { StandardGeneratorContext standardContext = (StandardGeneratorContext) context; return standardContext.getCompilationState().getClassFileMap(); } else { logger.log(TreeLogger.Type.WARN, String.format("Could not load generated classes from GWT context, " + "encountered unexpected generator type %s.", context.getClass())); return null; } } }
NameEnvironmentAnswer getNameEnvironmentAnswer() throws ClassFormatException { if (nameEnvironmentAnswer == null) { ClassFileReader cfr = new ClassFileReader(getBytes(), unit.getResourceLocation().toCharArray(), true); nameEnvironmentAnswer = new NameEnvironmentAnswer(cfr, null); } return nameEnvironmentAnswer; }
private boolean containsAllTypes(CompilationUnit unit, List<JDeclaredType> types) { Set<String> binaryTypeNames = new HashSet<String>(); for (JDeclaredType type : types) { binaryTypeNames.add(type.getName()); } for (CompiledClass cc : unit.getCompiledClasses()) { if (!binaryTypeNames.contains(InternalName.toBinaryName(cc.getInternalName()))) { return false; } } return true; }
private OverlayTypesRewriter createOverlayRewriter(CompilationState compilationState) { TypeOracle typeOracle = compilationState.getTypeOracle(); JClassType jsoType = typeOracle.findType(JsValueGlue.JSO_CLASS); // If we couldn't find the JSO class, we don't need to do any rewrites. return jsoType != null ? new OverlayTypesRewriter(compilationState, jsoType) : null; }
private boolean resolvePackage(TreeLogger logger, JRealClassType type, List<CollectAnnotationData> annotations) { Map<Class<? extends Annotation>, Annotation> declaredAnnotations = new HashMap<Class<? extends Annotation>, Annotation>(); resolveAnnotations(logger, annotations, declaredAnnotations); addAnnotations(type.getPackage(), declaredAnnotations); return true; }
private static JTypeParameter[] getTypeParametersForClass( CollectClassData classData) { JTypeParameter[] typeParams = null; if (classData.getSignature() != null) { // TODO(jat): do we need to consider generic types w/ method type // params for local classes? typeParams = collectTypeParams(classData.getSignature()); } return typeParams; }
private JType resolveArray(Type type) { assert type.getSort() == Type.ARRAY; JType resolvedType = resolveType(type.getElementType()); int dims = type.getDimensions(); for (int i = 0; i < dims; ++i) { resolvedType = typeOracle.getArrayType(resolvedType); } return resolvedType; }
/** * Returns the enclosing package, e.g. {@code java.util}. */ public String getPackageName() { return Shared.getPackageNameFromBinary(internalName); }
private boolean resolveAnnotations(TreeLogger logger, List<CollectAnnotationData> annotations, Map<Class<? extends Annotation>, Annotation> declaredAnnotations) { boolean succeeded = true; if (annotations != null) { for (CollectAnnotationData annotation : annotations) { succeeded &= resolveAnnotation(logger, annotation, declaredAnnotations); } } return succeeded; }
public TypeOracle getTypeOracle() { return getGeneratorContext().getTypeOracle(); }
public UnifyAst(TreeLogger logger, JProgram program, JsProgram jsProgram, JJSOptions options, RebindPermutationOracle rpo) { this.logger = logger; this.program = program; this.jsProgram = jsProgram; this.options = options; this.rpo = rpo; this.classFileMap = rpo.getCompilationState().getClassFileMap(); this.classFileMapBySource = rpo.getCompilationState().getClassFileMapBySource(); }
private OverlayTypesRewriter createOverlayRewriter(CompilationState compilationState) { TypeOracle typeOracle = compilationState.getTypeOracle(); JClassType jsoType = typeOracle.findType(JsValueGlue.JSO_CLASS); // If we couldn't find the JSO class, we don't need to do any rewrites. return jsoType != null ? new OverlayTypesRewriter(compilationState, jsoType) : null; }
@Override public TypeOracle getTypeOracle() { return getRebindPermutationOracle().getGeneratorContext().getTypeOracle(); }