private static CharSequence getRawType(MethodBinding methodBinding) { TypeBinding returnType = methodBinding.returnType; char[] sourceName = returnType.sourceName(); if (sourceName == null) { sourceName = new char[] {}; } return CharBuffer.wrap(sourceName); } }
@Override public CharSequence extract(ProcessingEnvironment environment, TypeElement typeElement) throws IOException { if (typeElement instanceof ElementImpl) { Binding binding = ((ElementImpl) typeElement)._binding; if (binding instanceof SourceTypeBinding) { CompilationUnitDeclaration unit = ((SourceTypeBinding) binding).scope.referenceCompilationUnit(); char[] contents = unit.compilationResult.compilationUnit.getContents(); return CharBuffer.wrap(contents); } } return UNABLE_TO_EXTRACT; }
@Override public CharSequence extractReturnType(ExecutableElement executableElement) { if (executableElement instanceof ExecutableElementImpl) { Binding binding = ((ExecutableElementImpl) executableElement)._binding; if (binding instanceof MethodBinding) { MethodBinding methodBinding = (MethodBinding) binding; @Nullable AbstractMethodDeclaration sourceMethod = methodBinding.sourceMethod(); if (sourceMethod != null) { CharSequence rawType = getRawType(methodBinding); char[] content = sourceMethod.compilationResult.compilationUnit.getContents(); int sourceEnd = methodBinding.sourceStart();// intentionaly int sourceStart = scanForTheSourceStart(content, sourceEnd); char[] methodTest = Arrays.copyOfRange(content, sourceStart, sourceEnd); Entry<String, List<String>> extracted = SourceTypes.extract(String.valueOf(methodTest)); return SourceTypes.stringify( Maps.immutableEntry(rawType.toString(), extracted.getValue())); } } } return UNABLE_TO_EXTRACT; }
ref = getTypeReference(((ParameterizedTypeBinding) binding).genericType()); } else if (binding instanceof ParameterizedTypeBinding) { if (binding.actualType() != null && binding.actualType() instanceof LocalTypeBinding) { ref = getTypeReference(binding.actualType()); } else { ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference(); this.exploringParameterizedBindings.put(binding, ref); if (binding.isAnonymousType()) { ref.setSimpleName(""); } else { ref.setSimpleName(String.valueOf(binding.sourceName())); if (binding.enclosingType() != null) { ref.setDeclaringType(getTypeReference(binding.enclosingType())); } else { ref.setPackage(getPackageReference(binding.getPackage())); if (binding.actualType() instanceof MissingTypeBinding) { ref = getTypeReference(binding.actualType()); ref.setSimpleName(new String(binding.sourceName())); ref.setPackage(getPackageReference(binding.getPackage())); if (!this.jdtTreeBuilder.getContextBuilder().ignoreComputeImports) { final CtReference declaring = this.getDeclaringReferenceFromImports(binding.sourceName()); if (declaring instanceof CtPackageReference) { ref.setPackage((CtPackageReference) declaring); if (binding.enclosingType() != null) { ref.setDeclaringType(getTypeReference(binding.enclosingType()));
if (exec.isConstructor()) { ref.setSimpleName(CtExecutableReference.CONSTRUCTOR_NAME); if (exec.declaringClass != null && Arrays.asList(exec.declaringClass.methods()).contains(exec)) { ref.setDeclaringType(getTypeReference(exec.declaringClass)); } else { final CtReference declaringType = getDeclaringReferenceFromImports(exec.constantPoolName()); if (declaringType instanceof CtTypeReference) { ref.setDeclaringType((CtTypeReference<?>) declaringType); if (exec.isConstructor()) { if (exec.isConstructor() && !(exec.returnType instanceof VoidTypeBinding)) { ref.setDeclaringType(getTypeReference(exec.returnType)); } else { ref.setDeclaringType(getTypeReference(exec.declaringClass)); ref.setStatic(exec.isStatic()); ref.setDeclaringType(getTypeReference(exec.declaringClass.actualType())); if (exec.original() != null) { final List<CtTypeReference<?>> parameters = new ArrayList<>(exec.original().parameters.length); for (TypeBinding b : exec.original().parameters) { parameters.add(getTypeReference(b, true));
try { if (packageName.length != 0) { aPackage = environment.createPackage(packageName); } else { aPackage = null; final MissingTypeBinding declaringType = environment.createMissingType(aPackage, className); this.jdtTreeBuilder.getContextBuilder().ignoreComputeImports = true; final CtTypeReference<Object> typeReference = getTypeReference(declaringType); Binding someBinding = cuDeclaration.scope.findImport(chars, false, false); if (someBinding != null && someBinding.isValidBinding() && someBinding instanceof PackageBinding) { packageBinding = (PackageBinding) someBinding; } else { try { packageBinding = environment.createPackage(chars); } catch (NullPointerException e) { packageBinding = null; packageBinding = new PackageBinding(chars, null, environment, environment.module);
boolean targetAnnotationExists = false; for (AnnotationBinding annotation : a.resolvedType.getAnnotations()) { if (!"Target".equals(CharOperation.charToString(annotation.getAnnotationType().sourceName()))) { continue; Object value = annotation.getElementValuePairs()[0].value; if (value == null) { continue;
/** * Searches a type from an entry-point according to a simple name. * * @param type * Entry-point to search. * @param simpleName * Expected type name. * @return type binding. */ static TypeBinding searchTypeBinding(ReferenceBinding type, String simpleName) { if (simpleName == null || type == null) { return null; } if (type.memberTypes() != null) { for (ReferenceBinding memberType : type.memberTypes()) { if (simpleName.equals(CharOperation.charToString(memberType.sourceName()))) { return memberType; } } } return searchTypeBinding(type.superclass(), simpleName); }
unit.scope.faultInTypes(); unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
protected int matchMethod(MethodBinding method, boolean skipImpossibleArg) { [...] // verify each parameter for (int i = 0; i < parameterCount; i++) { TypeBinding argType = method.parameters[i]; int newLevel = IMPOSSIBLE_MATCH; if (argType.isMemberType()) { // only compare source name for member type (bug 41018) newLevel = CharOperation.match(this.pattern.parameterSimpleNames[i], argType.sourceName(), this.isCaseSensitive) ? ACCURATE_MATCH : IMPOSSIBLE_MATCH; } else { // TODO (frederic) use this call to refine accuracy on parameter types // newLevel = resolveLevelForType(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i], this.pattern.parametersTypeArguments[i], 0, argType); newLevel = resolveLevelForType(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i], argType); [...] } } [...] }
@Override public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) { if ("package-info".equals(new String(typeDeclaration.name))) { context.enter(factory.Package().getOrCreate(new String(typeDeclaration.binding.fPackage.readableName())), typeDeclaration); return true; } else { CtModule module; // skip the type declaration that are already declared if (typeDeclaration.binding == null && getFactory().getEnvironment().isIgnoreDuplicateDeclarations()) { return false; } if (typeDeclaration.binding.module != null && !typeDeclaration.binding.module.isUnnamed() && typeDeclaration.binding.module.shortReadableName() != null && typeDeclaration.binding.module.shortReadableName().length > 0) { module = factory.Module().getOrCreate(String.valueOf(typeDeclaration.binding.module.shortReadableName())); } else { module = factory.Module().getUnnamedModule(); } CtPackage pack; if (typeDeclaration.binding.fPackage.shortReadableName() != null && typeDeclaration.binding.fPackage.shortReadableName().length > 0) { pack = factory.Package().getOrCreate(new String(typeDeclaration.binding.fPackage.shortReadableName()), module); } else { pack = module.getRootPackage(); } context.enter(pack, typeDeclaration); pack.addType(helper.createType(typeDeclaration)); return true; } }
/** * Creates a type access from its single name. * * @param singleNameReference * Used to get the simple name of the type. * @return a type access. */ <T> CtTypeAccess<T> createTypeAccessNoClasspath(SingleNameReference singleNameReference) { final CtTypeReference<T> typeReference = jdtTreeBuilder.getFactory().Core().createTypeReference(); if (singleNameReference.binding == null) { typeReference.setSimpleName(CharOperation.charToString(singleNameReference.token)); } else { typeReference.setSimpleName(CharOperation.charToString(singleNameReference.binding.readableName())); } jdtTreeBuilder.getReferencesBuilder().setPackageOrDeclaringType(typeReference, jdtTreeBuilder.getReferencesBuilder().getDeclaringReferenceFromImports(singleNameReference.token)); return jdtTreeBuilder.getFactory().Code().createTypeAccess(typeReference); }
/** * Checks if the qualified name reference is a problem field binding and have a valid field. * * @param qualifiedNameReference * Reference which should contains a problem field binding. * @return true if the qualified name reference is a valid problem field binding. */ static boolean isValidProblemBindingField(QualifiedNameReference qualifiedNameReference) { return qualifiedNameReference.binding instanceof ProblemFieldBinding && !((FieldBinding) qualifiedNameReference.binding).declaringClass.isAnonymousType() && qualifiedNameReference.tokens.length - 1 == ((FieldBinding) qualifiedNameReference.binding).declaringClass.compoundName.length && CharOperation .equals(CharOperation.subarray(qualifiedNameReference.tokens, 0, qualifiedNameReference.tokens.length - 1), ((FieldBinding) qualifiedNameReference.binding).declaringClass.compoundName); }
@Override public boolean visit(FieldDeclaration fieldDeclaration, MethodScope scope) { CtField<Object> field; if (fieldDeclaration.type != null) { field = factory.Core().createField(); } else { field = factory.Core().createEnumValue(); if (fieldDeclaration.binding != null) { field.setType(references.getTypeReference(fieldDeclaration.binding.type)); } } field.setSimpleName(CharOperation.charToString(fieldDeclaration.name)); if (fieldDeclaration.binding != null) { if (fieldDeclaration.binding.declaringClass != null && fieldDeclaration.binding.declaringClass.isEnum() && field instanceof CtEnumValue) { //enum values take over visibility from enum type //JDT compiler has a bug that enum values are always public static final, even for private enum field.setExtendedModifiers(getModifiers(fieldDeclaration.binding.declaringClass.modifiers, true, false)); } else { field.setExtendedModifiers(getModifiers(fieldDeclaration.binding.modifiers, true, false)); } } for (CtExtendedModifier extendedModifier : getModifiers(fieldDeclaration.modifiers, false, false)) { field.addModifier(extendedModifier.getKind()); // avoid to keep implicit AND explicit modifier of the same kind. } context.enter(field, fieldDeclaration); return true; }
/** * Builds a qualified type reference from a {@link TypeReference}. * * @param type Qualified type from JDT. * @param scope Scope of the parent element. * @return */ <T> CtTypeReference<T> buildTypeReference(QualifiedTypeReference type, Scope scope) { CtTypeReference<T> accessedType = buildTypeReference((TypeReference) type, scope); final TypeBinding receiverType = type != null ? type.resolvedType : null; if (receiverType != null) { final CtTypeReference<T> ref = getQualifiedTypeReference(type.tokens, receiverType, receiverType.enclosingType(), new JDTTreeBuilder.OnAccessListener() { @Override public boolean onAccess(char[][] tokens, int index) { return true; } }); if (ref != null) { accessedType = ref; } } return accessedType; }
<T> CtFieldReference<T> getVariableReference(FieldBinding varbin) { CtFieldReference<T> ref = this.jdtTreeBuilder.getFactory().Core().createFieldReference(); if (varbin == null) { return ref; } ref.setSimpleName(new String(varbin.name)); ref.setType(this.<T>getTypeReference(varbin.type)); if (varbin.declaringClass != null) { ref.setDeclaringType(getTypeReference(varbin.declaringClass)); } else { ref.setDeclaringType(ref.getType() == null ? null : ref.getType().clone()); } ref.setFinal(varbin.isFinal()); ref.setStatic((varbin.modifiers & ClassFileConstants.AccStatic) != 0); return ref; }
/** * In no classpath mode, when we build a field access, we have a binding typed by ProblemBinding. * We try to get all information we can get from this binding. * * @param qualifiedNameReference * Used to get the problem binding of the field access and the name of the declaring type. * @return a field access. */ <T> CtFieldAccess<T> createFieldAccessNoClasspath(QualifiedNameReference qualifiedNameReference) { boolean fromAssignment = isLhsAssignment(jdtTreeBuilder.getContextBuilder(), qualifiedNameReference); CtFieldAccess<T> fieldAccess = createFieldAccess(jdtTreeBuilder.getReferencesBuilder().<T>getVariableReference((ProblemBinding) qualifiedNameReference.binding), null, fromAssignment); // In no classpath mode and with qualified name, the type given by JDT is wrong... final char[][] declaringClass = CharOperation.subarray(qualifiedNameReference.tokens, 0, qualifiedNameReference.tokens.length - 1); final MissingTypeBinding declaringType = jdtTreeBuilder.getContextBuilder().compilationunitdeclaration.scope.environment.createMissingType(null, declaringClass); final CtTypeReference<T> declaringRef = jdtTreeBuilder.getReferencesBuilder().getTypeReference(declaringType); fieldAccess.getVariable().setDeclaringType(declaringRef); fieldAccess.getVariable().setStatic(true); fieldAccess.setTarget(jdtTreeBuilder.getFactory().Code().createTypeAccess(declaringRef)); // In no classpath mode and with qualified name, the binding doesn't have a good name. fieldAccess.getVariable() .setSimpleName(createQualifiedTypeName(CharOperation.subarray(qualifiedNameReference.tokens, qualifiedNameReference.tokens.length - 1, qualifiedNameReference.tokens.length))); return fieldAccess; }
@Override public <T> void visitCtNewClass(CtNewClass<T> newClass) { if (child instanceof CtClass) { newClass.setAnonymousClass((CtClass<?>) child); final QualifiedAllocationExpression node = (QualifiedAllocationExpression) jdtTreeBuilder.getContextBuilder().stack.peek().node; final ReferenceBinding[] referenceBindings = node.resolvedType == null ? null : node.resolvedType.superInterfaces(); if (referenceBindings != null && referenceBindings.length > 0) { ((CtClass<?>) child).addSuperInterface(newClass.getType().clone()); } else if (newClass.getType() != null) { ((CtClass<?>) child).setSuperclass(newClass.getType().clone()); } return; } super.visitCtNewClass(newClass); }
private CtPackageReference getPackageReference(PackageBinding reference) { return getPackageReference(new String(reference.shortReadableName())); }
@Override public boolean visit(LambdaExpression lambdaExpression, BlockScope blockScope) { CtLambda<?> lambda = factory.Core().createLambda(); final MethodBinding methodBinding = lambdaExpression.getMethodBinding(); if (methodBinding != null) { lambda.setSimpleName(CharOperation.charToString(methodBinding.constantPoolName())); } context.isBuildLambda = true; context.enter(lambda, lambdaExpression); return true; }