public URI getFullURI(ITypeBinding typeBinding) { // The URIs for primitive types are cached and indexed by their one character key // representation. // if (typeBinding.isPrimitive()) { return PRIMITIVE_URIS[typeBinding.getKey().charAt(0) - 'B']; } if (typeBinding.isClass() || typeBinding.isInterface() || typeBinding.isAnnotation() || typeBinding.isEnum()) { ITypeBinding declaringClass = typeBinding.getDeclaringClass(); if (declaringClass == null) { // This special case handling for common case of top level types that avoids creating a // builder. // String qualifiedName = typeBinding.getErasure().getQualifiedName(); URI uri = COMMON_URIS.get(qualifiedName); if (uri != null) { return uri; } uri = OBJECTS_URI.appendSegment(qualifiedName); return uri.appendFragment(uri.lastSegment()); } SegmentSequence.Builder builder = SegmentSequence.newBuilder(""); URI uri = getFullURI(declaringClass, builder); builder.append("$"); builder.append(typeBinding.getName()); return uri.appendFragment(builder.toString()); } SegmentSequence.Builder builder = SegmentSequence.newBuilder(""); URI uri = getFullURI(typeBinding, builder); return uri.appendFragment(builder.toString()); }
/** @since 2.4 */ protected URI getFullURI(ITypeBinding typeBinding, SegmentSequence.Builder builder) { if (typeBinding.isPrimitive()) { builder.append(PRIMITIVE_URIS[typeBinding.getKey().charAt(0) - 'B'].fragment()); return PRIMITIVES_URI; } if (typeBinding.isClass() || typeBinding.isInterface() || typeBinding.isAnnotation() || typeBinding.isEnum()) { ITypeBinding declaringClass = typeBinding.getDeclaringClass(); if (declaringClass != null) { URI uri = getFullURI(declaringClass, builder); builder.append("$"); builder.append(typeBinding.getName()); return uri; } String qualifiedName = typeBinding.getErasure().getQualifiedName(); URI uri = COMMON_URIS.get(qualifiedName); if (uri == null) { uri = OBJECTS_URI.appendSegment(qualifiedName); } builder.append(uri.lastSegment()); return uri; } if (typeBinding.isArray()) { URI uri = getFullURI(typeBinding.getComponentType(), builder); builder.append("[]"); return uri; } if (typeBinding.isTypeVariable()) { ITypeBinding declaringClass = typeBinding.getDeclaringClass(); if (declaringClass != null) { URI uri = getFullURI(declaringClass, builder); builder.append("/"); builder.append(typeBinding.getName()); return uri; } IMethodBinding declaringMethod = typeBinding.getDeclaringMethod(); URI uri = getFullURI(declaringMethod.getDeclaringClass(), builder); builder.append("."); builder.append(declaringMethod.getName()); builder.append("("); ITypeBinding[] parameterTypes = declaringMethod.getParameterTypes(); for (int i = 0; i < parameterTypes.length; i++) { if (i != 0) { builder.append(","); } getQualifiedName(parameterTypes[i], builder); } builder.append(")"); builder.append("/"); builder.append(typeBinding.getName()); return uri; } throw new IllegalStateException("Unexpected type: " + typeBinding); }
private SmellyClass getPossibleRole(ITypeBinding tb) { String className = tb.getQualifiedName(); SmellyClass possibleService; if (tb.isInterface()) { List<SmellyClass> subtypes = repo.getSubtypesOf(className); possibleService = findRole(subtypes); } else { possibleService = repo.getByClass(className); } return possibleService; }
/** Returns the type binding for a specific interface of a specific type. */ public static ITypeBinding findInterface(ITypeBinding implementingType, String qualifiedName) { if (implementingType.isInterface() && implementingType.getErasure().getQualifiedName().equals(qualifiedName)) { return implementingType; } for (ITypeBinding interfaze : getAllInterfaces(implementingType)) { if (interfaze.getErasure().getQualifiedName().equals(qualifiedName)) { return interfaze; } } return null; }
/** * Get a method's signature for dead code elimination purposes. * * <p>Since DeadCodeEliminator runs before InnerClassExtractor, inner class constructors do not * yet have the parameter for capturing outer class, and therefore we need this special case. */ public static String getProGuardSignature(IMethodBinding binding) { StringBuilder sb = new StringBuilder("("); // If the method is an inner class constructor, prepend the outer class type. if (binding.isConstructor()) { ITypeBinding declClass = binding.getDeclaringClass(); ITypeBinding outerClass = declClass.getDeclaringClass(); if (outerClass != null && !declClass.isInterface() && !declClass.isAnnotation() && !Modifier.isStatic(declClass.getModifiers())) { appendParameterSignature(outerClass.getErasure(), sb); } } appendParametersSignature(binding, sb); sb.append(')'); appendReturnTypeSignature(binding, sb); return sb.toString(); }
protected Import getReference(ITypeBinding binding) { if (!binding.isTypeVariable() && !binding.isPrimitive() && !binding.isAnnotation() // Don't import IOS types, other than the IOS array types, // since they have header files. && (binding instanceof IOSArrayTypeBinding || !(binding instanceof IOSTypeBinding))) { binding = Types.mapType(binding); String typeName = NameTable.getFullName(binding); boolean isInterface = binding.isInterface(); while (!binding.isTopLevel()) { binding = binding.getDeclaringClass(); } return getReference(typeName, binding.getErasure().getQualifiedName(), isInterface); } else if (binding.isTypeVariable()) { ITypeBinding[] typeBounds = binding.getTypeBounds(); if (typeBounds.length > 0 && !Types.isJavaObjectType(typeBounds[0])) { return getReference(typeBounds[0]); } } return NULL_IMPORT; }
protected void createResourceURI(ITypeBinding typeBinding, StringBuilder uriBuilder) { if (typeBinding.isPrimitive()) { createResourceURIForPrimitive(uriBuilder); return; } if (typeBinding.isClass() || typeBinding.isInterface() || typeBinding.isAnnotation() || typeBinding.isEnum()) { createResourceURIForClass(typeBinding, uriBuilder); return; } if (typeBinding.isArray()) { createResourceURIForArray(typeBinding, uriBuilder); return; } if (typeBinding.isTypeVariable()) { createResourceURIForTypeVariable(typeBinding, uriBuilder); return; } throw new IllegalStateException("Unexpected type: " + typeBinding); }
private int evaluateFieldModifiers(ASTNode newTypeDecl) { if (fSenderBinding.isAnnotation()) { return 0; } if (fSenderBinding.isInterface()) { // for interface members copy the modifiers from an existing field FieldDeclaration[] fieldDecls = ((TypeDeclaration) newTypeDecl).getFields(); if (fieldDecls.length > 0) { return fieldDecls[0].getModifiers(); } return 0; } int modifiers = 0; if (fVariableKind == CONST_FIELD) { modifiers |= Modifier.FINAL | Modifier.STATIC; } else { ASTNode parent = fOriginalNode.getParent(); if (parent instanceof QualifiedName) { IBinding qualifierBinding = ((QualifiedName) parent).getQualifier().resolveBinding(); if (qualifierBinding instanceof ITypeBinding) { modifiers |= Modifier.STATIC; } } else if (ASTResolving.isInStaticContext(fOriginalNode)) { modifiers |= Modifier.STATIC; } } ASTNode node = ASTResolving.findParentType(fOriginalNode, true); if (newTypeDecl.equals(node)) { modifiers |= Modifier.PRIVATE; } else if (node instanceof AnonymousClassDeclaration) { modifiers |= Modifier.PROTECTED; } else { modifiers |= Modifier.PUBLIC; } return modifiers; }
private FunctionInvocation createCastCheck(ITypeBinding type, Expression expr) { type = type.getErasure(); ITypeBinding idType = typeEnv.resolveIOSType("id"); FunctionInvocation invocation = null; if ((type.isInterface() && !type.isAnnotation()) || (type.isArray() && !type.getComponentType().isPrimitive())) { FunctionBinding binding = new FunctionBinding("cast_check", idType, null); binding.addParameters(idType, typeEnv.getIOSClass()); invocation = new FunctionInvocation(binding, idType); invocation.getArguments().add(TreeUtil.remove(expr)); invocation.getArguments().add(new TypeLiteral(type, typeEnv)); } else if (type.isClass() || type.isArray() || type.isAnnotation() || type.isEnum()) { FunctionBinding binding = new FunctionBinding("cast_chk", idType, null); binding.addParameters(idType, idType); invocation = new FunctionInvocation(binding, idType); invocation.getArguments().add(TreeUtil.remove(expr)); IOSMethodBinding classBinding = IOSMethodBinding.newMethod("class", Modifier.STATIC, idType, type); MethodInvocation classInvocation = new MethodInvocation(classBinding, new SimpleName(type)); invocation.getArguments().add(classInvocation); } return invocation; }
@Override public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException { try { pm.beginTask("", 7); // $NON-NLS-1$ RefactoringStatus result = Checks.validateEdit(fCu, getValidationContext()); if (result.hasFatalError()) return result; pm.worked(1); if (fCuRewrite == null) { CompilationUnit cuNode = RefactoringASTParser.parseWithASTProvider(fCu, true, new SubProgressMonitor(pm, 3)); fCuRewrite = new CompilationUnitRewrite(fCu, cuNode); } else { pm.worked(3); } result.merge(checkSelection(new SubProgressMonitor(pm, 3))); if (result.hasFatalError()) return result; if (isLiteralNodeSelected()) fReplaceAllOccurrences = false; if (isInTypeDeclarationAnnotation(getSelectedExpression().getAssociatedNode())) { fVisibility = JdtFlags.VISIBILITY_STRING_PACKAGE; } ITypeBinding targetType = getContainingTypeBinding(); if (targetType.isInterface()) { fTargetIsInterface = true; fVisibility = JdtFlags.VISIBILITY_STRING_PUBLIC; } return result; } finally { pm.done(); } }
private ASTRewrite doAddField(CompilationUnit astRoot) { SimpleName node = fOriginalNode; boolean isInDifferentCU = false; ASTNode newTypeDecl = astRoot.findDeclaringNode(fSenderBinding); if (newTypeDecl == null) { astRoot = ASTResolving.createQuickFixAST(getCompilationUnit(), null); newTypeDecl = astRoot.findDeclaringNode(fSenderBinding.getKey()); isInDifferentCU = true; } ImportRewrite imports = createImportRewrite(astRoot); ImportRewriteContext importRewriteContext = new ContextSensitiveImportRewriteContext( ASTResolving.findParentBodyDeclaration(node), imports); if (newTypeDecl != null) { AST ast = newTypeDecl.getAST(); ASTRewrite rewrite = ASTRewrite.create(ast); VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment(); fragment.setName(ast.newSimpleName(node.getIdentifier())); Type type = evaluateVariableType(ast, imports, importRewriteContext, fSenderBinding); FieldDeclaration newDecl = ast.newFieldDeclaration(fragment); newDecl.setType(type); newDecl .modifiers() .addAll(ASTNodeFactory.newModifiers(ast, evaluateFieldModifiers(newTypeDecl))); if (fSenderBinding.isInterface() || fVariableKind == CONST_FIELD) { fragment.setInitializer(ASTNodeFactory.newDefaultExpression(ast, type, 0)); } ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(newTypeDecl); List<BodyDeclaration> decls = ASTNodes.<BodyDeclaration>getChildListProperty(newTypeDecl, property); int maxOffset = isInDifferentCU ? -1 : node.getStartPosition(); int insertIndex = findFieldInsertIndex(decls, newDecl, maxOffset); ListRewrite listRewriter = rewrite.getListRewrite(newTypeDecl, property); listRewriter.insertAt(newDecl, insertIndex, null); ModifierCorrectionSubProcessor.installLinkedVisibilityProposals( getLinkedProposalModel(), rewrite, newDecl.modifiers(), fSenderBinding.isInterface()); addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE); if (!isInDifferentCU) { addLinkedPosition(rewrite.track(node), true, KEY_NAME); } addLinkedPosition(rewrite.track(fragment.getName()), false, KEY_NAME); if (fragment.getInitializer() != null) { addLinkedPosition(rewrite.track(fragment.getInitializer()), false, KEY_INITIALIZER); } return rewrite; } return null; }
@Override public boolean visit(TypeDeclaration node) { if (node.isPackageMemberTypeDeclaration() || node.isMemberTypeDeclaration()) { ITypeBinding typeBinding = node.resolveBinding(); if (typeBinding != null) { // Criando classe ApiClass apiClass = new ApiClass(typeBinding.getQualifiedName()); apiClass.setInterface(typeBinding.isInterface()); this.setModifiers(apiClass, node); this.classMap.put(typeBinding, apiClass); if (!this.attachmentMap.containsKey(node.getRoot())) { Attachment attachment = new Attachment( typeBinding.getQualifiedName().concat(".java"), node.getRoot().toString().getBytes()); this.attachmentMap.put(node.getRoot(), attachment); } List<MethodDeclaration> declarations = new LinkedList<MethodDeclaration>(); for (Object o : node.bodyDeclarations()) { if (o instanceof MethodDeclaration) { declarations.add((MethodDeclaration) o); } } for (final MethodDeclaration declaration : declarations) { final List<Expression> invocations = new LinkedList<Expression>(); this.methodDeclarationHandler(declaration, apiClass); InvocationVisitor visitor = new InvocationVisitor(); declaration.accept(visitor); invocations.addAll(visitor.invocations); // Parte de extracao de exemplos, se não houver invocações eu pulo esta parte if (invocations.isEmpty()) { continue; } else { // Faço a extração de exemplos para cada invocação em separado Set<ApiMethod> methodsInvocations = new HashSet<ApiMethod>(); for (Expression mi : invocations) { methodsInvocations.add(this.mapInvocations.get(mi)); Example newExample = makeExample( declaration, Collections.singleton(mi), Collections.singletonList(this.mapInvocations.get(mi))); if (newExample != null) { this.examples.add(newExample); } } // Se houver mais de uma invocacao faço o slicing com sementes multiplas if (invocations.size() > 1) { // Itero sobre os conjuntos das regras Iterator<Set<ApiMethod>> it = this.methodSets.iterator(); while (it.hasNext()) { // Podando conjuntos Set<ApiMethod> s = it.next(); if (s.size() > methodsInvocations.size()) { break; } else { // Se as invocacoes identificadas envolvem metodos desejados eu processo if (methodsInvocations.containsAll(s)) { List<ApiMethod> methods = new ArrayList<ApiMethod>(); Set<Expression> invocationsTemp = new HashSet<Expression>(); for (Expression mi : invocations) { ApiMethod relatedMethod = this.mapInvocations.get(mi); if (s.contains(relatedMethod)) { methods.add(relatedMethod); invocationsTemp.add(mi); } } Example newExample = makeExample(declaration, invocationsTemp, methods); if (newExample != null) { this.examples.add(newExample); } } } } } } } } } return super.visit(node); }
public ClassDeclarationImpl(final ITypeBinding binding, final BaseProcessorEnv env) { super(binding, env); // Enum types return false for isClass(). assert !binding.isInterface(); }