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();
}
