diff --git a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaClassDef.java b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaClassDef.java index 11df39c3..c954702a 100644 --- a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaClassDef.java +++ b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaClassDef.java @@ -97,12 +97,7 @@ public class SmalideaClassDef extends BaseTypeReference implements ClassDef { } @Nonnull @Override public String getType() { - // TODO: properly handle inner classes.. - String javaName = psiClass.getQualifiedName(); - if (javaName == null) { - throw new RuntimeException("I don't know what to do here... Is this even possible?"); - } - return NameUtils.javaToSmaliType(javaName); + return NameUtils.javaToSmaliType(psiClass); } @Nullable @Override public String getSuperclass() { @@ -110,11 +105,7 @@ public class SmalideaClassDef extends BaseTypeReference implements ClassDef { if (superClass == null) { return null; } - String javaName = superClass.getQualifiedName(); - if (javaName == null) { - throw new RuntimeException("I don't know what to do here... Is this even possible?"); - } - return NameUtils.javaToSmaliType(javaName); + return NameUtils.javaToSmaliType(superClass); } @Nonnull @Override public List getInterfaces() { @@ -125,11 +116,7 @@ public class SmalideaClassDef extends BaseTypeReference implements ClassDef { } for (PsiClass psiClass: interfaces) { - String javaName = psiClass.getQualifiedName(); - if (javaName == null) { - throw new RuntimeException("I don't know what to do here... Is this even possible?"); - } - interfaceList.add(NameUtils.javaToSmaliType(javaName)); + interfaceList.add(NameUtils.javaToSmaliType(psiClass)); } return interfaceList; diff --git a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaField.java b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaField.java index bb022792..7b98174a 100644 --- a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaField.java +++ b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaField.java @@ -93,11 +93,7 @@ public class SmalideaField extends BaseFieldReference implements Field { if (containingClass == null) { throw new RuntimeException("I don't know what to do here... Is this even possible?"); } - String javaName = containingClass.getQualifiedName(); - if (javaName == null) { - throw new RuntimeException("I don't know what to do here... Is this even possible?"); - } - return NameUtils.javaToSmaliType(javaName); + return NameUtils.javaToSmaliType(containingClass); } @Nonnull @Override public String getName() { @@ -105,8 +101,7 @@ public class SmalideaField extends BaseFieldReference implements Field { } @Nonnull @Override public String getType() { - String javaName = psiField.getType().getCanonicalText(); - return NameUtils.javaToSmaliType(javaName); + return NameUtils.javaToSmaliType(psiField.getType()); } @Nullable @Override public EncodedValue getInitialValue() { diff --git a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethod.java b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethod.java index a6c5c88a..abc4dda8 100644 --- a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethod.java +++ b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethod.java @@ -67,9 +67,7 @@ public class SmalideaMethod extends BaseMethodReference implements Method { @Nonnull @Override public String getDefiningClass() { PsiClass cls = psiMethod.getContainingClass(); assert cls != null; - String qualifiedName = cls.getQualifiedName(); - assert qualifiedName != null; - return NameUtils.javaToSmaliType(qualifiedName); + return NameUtils.javaToSmaliType(cls); } @Nonnull @Override public List getParameters() { diff --git a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethodParameter.java b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethodParameter.java index e9e26a7c..49d75c83 100644 --- a/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethodParameter.java +++ b/smalidea/src/main/java/org/jf/smalidea/dexlib/SmalideaMethodParameter.java @@ -59,6 +59,6 @@ public class SmalideaMethodParameter extends BaseMethodParameter { } @Nonnull @Override public String getType() { - return NameUtils.javaToSmaliType(psiParameter.getType().getCanonicalText()); + return NameUtils.javaToSmaliType(psiParameter.getType()); } } diff --git a/smalidea/src/main/java/org/jf/smalidea/dexlib/analysis/SmalideaClassProvider.java b/smalidea/src/main/java/org/jf/smalidea/dexlib/analysis/SmalideaClassProvider.java index e886a290..9d2a14ac 100644 --- a/smalidea/src/main/java/org/jf/smalidea/dexlib/analysis/SmalideaClassProvider.java +++ b/smalidea/src/main/java/org/jf/smalidea/dexlib/analysis/SmalideaClassProvider.java @@ -2,7 +2,6 @@ package org.jf.smalidea.dexlib.analysis; import com.intellij.openapi.project.Project; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiClass; import com.intellij.psi.impl.ResolveScopeManager; import org.jf.dexlib2.analysis.ClassProvider; @@ -24,10 +23,7 @@ public class SmalideaClassProvider implements ClassProvider { @Nullable @Override public ClassDef getClassDef(String type) { ResolveScopeManager manager = ResolveScopeManager.getInstance(project); - - JavaPsiFacade facade = JavaPsiFacade.getInstance(project); - PsiClass psiClass = facade.findClass(NameUtils.smaliToJavaType(type), - manager.getDefaultResolveScope(file)); + PsiClass psiClass = NameUtils.resolveSmaliType(project, manager.getDefaultResolveScope(file), type); if (psiClass != null) { return new SmalideaClassDef(psiClass); } diff --git a/smalidea/src/main/java/org/jf/smalidea/dexlib/instruction/SmalideaInstruction.java b/smalidea/src/main/java/org/jf/smalidea/dexlib/instruction/SmalideaInstruction.java index 4bd1616a..b5b259a2 100644 --- a/smalidea/src/main/java/org/jf/smalidea/dexlib/instruction/SmalideaInstruction.java +++ b/smalidea/src/main/java/org/jf/smalidea/dexlib/instruction/SmalideaInstruction.java @@ -193,7 +193,7 @@ public abstract class SmalideaInstruction implements Instruction { if (psiType == null) { return null; } - return NameUtils.javaToSmaliType(psiType.getCanonicalText()); + return NameUtils.javaToSmaliType(psiType); } }); diff --git a/smalidea/src/main/java/org/jf/smalidea/findUsages/SmaliClassReferenceSearcher.java b/smalidea/src/main/java/org/jf/smalidea/findUsages/SmaliClassReferenceSearcher.java index 4642d749..63e4d6fe 100644 --- a/smalidea/src/main/java/org/jf/smalidea/findUsages/SmaliClassReferenceSearcher.java +++ b/smalidea/src/main/java/org/jf/smalidea/findUsages/SmaliClassReferenceSearcher.java @@ -55,18 +55,20 @@ public class SmaliClassReferenceSearcher extends QueryExecutorBase() { @Override public String compute() { - return ((PsiClass)element).getQualifiedName(); + String qualifiedName = ((PsiClass)element).getQualifiedName(); + if (qualifiedName != null) { + return NameUtils.javaToSmaliType((PsiClass)element); + } + return null; } }); - if (qualifiedName == null) { + if (smaliType == null) { return; } - String smaliType = NameUtils.javaToSmaliType(qualifiedName); - final StringSearcher stringSearcher = new StringSearcher(smaliType, true, true, false, false); final SingleTargetRequestResultProcessor processor = new SingleTargetRequestResultProcessor(element); diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/impl/LightSmaliClassTypeElement.java b/smalidea/src/main/java/org/jf/smalidea/psi/impl/LightSmaliClassTypeElement.java index f5dd6773..acd9a02a 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/impl/LightSmaliClassTypeElement.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/impl/LightSmaliClassTypeElement.java @@ -46,15 +46,15 @@ import org.jf.smalidea.util.NameUtils; public class LightSmaliClassTypeElement extends LightElement implements PsiTypeElement, PsiReference, PsiJavaCodeReferenceElement { @NotNull - private final String qualifiedName; + private final String smaliName; - public LightSmaliClassTypeElement(@NotNull PsiManager manager, @NotNull String qualifiedName) { + public LightSmaliClassTypeElement(@NotNull PsiManager manager, @NotNull String smaliName) { super(manager, SmaliLanguage.INSTANCE); - this.qualifiedName = qualifiedName; + this.smaliName = smaliName; } @Override public String toString() { - return "LightSmaliClassTypeElement:" + qualifiedName; + return "LightSmaliClassTypeElement:" + smaliName; } @NotNull @Override public PsiType getType() { @@ -66,7 +66,7 @@ public class LightSmaliClassTypeElement extends LightElement } @Override public String getText() { - return NameUtils.javaToSmaliType(qualifiedName); + return smaliName; } @Override public PsiReference getReference() { @@ -82,12 +82,11 @@ public class LightSmaliClassTypeElement extends LightElement } @Nullable @Override public PsiClass resolve() { - JavaPsiFacade facade = JavaPsiFacade.getInstance(getProject()); - return facade.findClass(getCanonicalText(), getResolveScope()); + return NameUtils.resolveSmaliType(this, smaliName); } @NotNull @Override public String getCanonicalText() { - return qualifiedName; + return NameUtils.resolveSmaliToJavaType(this, smaliName); } @Override public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException { diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliAnnotation.java b/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliAnnotation.java index 745416e5..e36313ba 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliAnnotation.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliAnnotation.java @@ -58,24 +58,32 @@ public class SmaliAnnotation extends SmaliStubBasedPsiElement extends SmaliStubBasedPsiElement implements StubBasedPsiElement, PsiReferenceList { @@ -68,7 +69,14 @@ public abstract class SmaliBaseReferenceList implements SmaliModifierListOwner { @@ -83,7 +84,9 @@ public class SmaliClassStatement extends SmaliStubBasedPsiElement implements PsiField, SmaliModifierListOwner { public SmaliField(@NotNull SmaliFieldStub stub) { @@ -93,9 +94,7 @@ public class SmaliField extends SmaliStubBasedPsiElement impleme @NotNull @Override public PsiType getType() { SmaliFieldStub stub = getStub(); if (stub != null) { - String type = stub.getType(); - PsiElementFactory factory = JavaPsiFacade.getInstance(getProject()).getElementFactory(); - return factory.createTypeFromText(type, this); + return NameUtils.resolveSmaliToPsiType(this, stub.getSmaliTypeName()); } PsiTypeElement typeElement = getTypeElement(); if (typeElement == null) { @@ -106,8 +105,8 @@ public class SmaliField extends SmaliStubBasedPsiElement impleme return getTypeElement().getType(); } - @Nullable @Override public PsiTypeElement getTypeElement() { - return findChildByClass(PsiTypeElement.class); + @Nullable @Override public SmaliTypeElement getTypeElement() { + return findChildByClass(SmaliTypeElement.class); } @Nullable @Override public PsiExpression getInitializer() { diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliMethodParameter.java b/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliMethodParameter.java index 61683a5d..93d376e8 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliMethodParameter.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/impl/SmaliMethodParameter.java @@ -41,6 +41,7 @@ import org.jetbrains.annotations.Nullable; import org.jf.smalidea.psi.SmaliElementTypes; import org.jf.smalidea.psi.iface.SmaliModifierListOwner; import org.jf.smalidea.psi.stub.SmaliMethodParameterStub; +import org.jf.smalidea.util.NameUtils; public class SmaliMethodParameter extends SmaliStubBasedPsiElement implements PsiParameter, SmaliModifierListOwner { @@ -83,8 +84,7 @@ public class SmaliMethodParameter extends SmaliStubBasedPsiElement { public SmaliMethodPrototype(@NotNull SmaliMethodPrototypeStub stub) { @@ -54,12 +52,11 @@ public class SmaliMethodPrototype extends SmaliStubBasedPsiElement { @Nullable - private final String annotationType; + private final String annotationSmaliTypeName; - public SmaliAnnotationStub(StubElement parent, @Nullable String annotationType) { + public SmaliAnnotationStub(StubElement parent, @Nullable String annotationSmaliTypeName) { super(parent, SmaliElementTypes.ANNOTATION); - this.annotationType = annotationType; + this.annotationSmaliTypeName = annotationSmaliTypeName; } @Nullable - public String getAnnotationType() { - return annotationType; + public String getAnnotationSmaliTypeName() { + return annotationSmaliTypeName; } } diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliBaseReferenceListStub.java b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliBaseReferenceListStub.java index ce9dede6..8521c4b4 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliBaseReferenceListStub.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliBaseReferenceListStub.java @@ -42,26 +42,26 @@ import org.jf.smalidea.psi.impl.SmaliBaseReferenceList; import org.jf.smalidea.psi.impl.SmaliClassType; public abstract class SmaliBaseReferenceListStub extends StubBase { - @NotNull private final String[] types; + @NotNull private final String[] smaliTypeNames; @Nullable private SmaliClassType[] classTypes = null; protected SmaliBaseReferenceListStub( - @NotNull StubElement parent, @NotNull IStubElementType elementType, @NotNull String[] types) { + @NotNull StubElement parent, @NotNull IStubElementType elementType, @NotNull String[] smaliTypeNames) { super(parent, elementType); - this.types = types; + this.smaliTypeNames = smaliTypeNames; } - @NotNull public String[] getTypes() { - return types; + @NotNull public String[] getSmaliTypeNames() { + return smaliTypeNames; } @NotNull public SmaliClassType[] getReferencedTypes() { if (classTypes == null) { - classTypes = new SmaliClassType[types.length]; - for (int i=0; i { - public SmaliExtendsListStub(@NotNull StubElement parent, @NotNull String[] types) { - super(parent, SmaliElementTypes.EXTENDS_LIST, types); + public SmaliExtendsListStub(@NotNull StubElement parent, @NotNull String[] smaliTypeNames) { + super(parent, SmaliElementTypes.EXTENDS_LIST, smaliTypeNames); } } diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliFieldStub.java b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliFieldStub.java index 9507c383..15e0fbf0 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliFieldStub.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliFieldStub.java @@ -40,19 +40,19 @@ import org.jf.smalidea.psi.impl.SmaliField; public class SmaliFieldStub extends StubBase { @Nullable private final String name; - @NotNull private final String type; + @NotNull private final String smaliTypeName; - public SmaliFieldStub(StubElement parent, @Nullable String name, @NotNull String type) { + public SmaliFieldStub(StubElement parent, @Nullable String name, @NotNull String smaliTypeName) { super(parent, SmaliElementTypes.FIELD); this.name = name; - this.type = type; + this.smaliTypeName = smaliTypeName; } @Nullable public String getName() { return name; } - @NotNull public String getType() { - return type; + @NotNull public String getSmaliTypeName() { + return smaliTypeName; } } diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliImplementsListStub.java b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliImplementsListStub.java index c09d087f..2b762c9f 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliImplementsListStub.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliImplementsListStub.java @@ -37,7 +37,7 @@ import org.jf.smalidea.psi.SmaliElementTypes; import org.jf.smalidea.psi.impl.SmaliImplementsList; public class SmaliImplementsListStub extends SmaliBaseReferenceListStub { - public SmaliImplementsListStub(@NotNull StubElement parent, @NotNull String[] types) { - super(parent, SmaliElementTypes.IMPLEMENTS_LIST, types); + public SmaliImplementsListStub(@NotNull StubElement parent, @NotNull String[] smaliTypeNames) { + super(parent, SmaliElementTypes.IMPLEMENTS_LIST, smaliTypeNames); } } diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodParameterStub.java b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodParameterStub.java index d8bc099e..e6f1cf25 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodParameterStub.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodParameterStub.java @@ -39,17 +39,17 @@ import org.jf.smalidea.psi.SmaliElementTypes; import org.jf.smalidea.psi.impl.SmaliMethodParameter; public class SmaliMethodParameterStub extends StubBase { - @NotNull private final String type; + @NotNull private final String smaliTypeName; @Nullable private final String name; - public SmaliMethodParameterStub(@NotNull StubElement parent, @NotNull String type, @Nullable String name) { + public SmaliMethodParameterStub(@NotNull StubElement parent, @NotNull String smaliTypeName, @Nullable String name) { super(parent, SmaliElementTypes.METHOD_PARAMETER); - this.type = type; + this.smaliTypeName = smaliTypeName; this.name = name; } - @NotNull public String getType() { - return type; + @NotNull public String getSmaliTypeName() { + return smaliTypeName; } @Nullable public String getName() { diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodPrototypeStub.java b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodPrototypeStub.java index 81e42c5e..ac0b1e9a 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodPrototypeStub.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/stub/SmaliMethodPrototypeStub.java @@ -39,14 +39,14 @@ import org.jf.smalidea.psi.SmaliElementTypes; import org.jf.smalidea.psi.impl.SmaliMethodPrototype; public class SmaliMethodPrototypeStub extends StubBase { - @Nullable private final String returnType; + @Nullable private final String returnSmaliTypeName; - public SmaliMethodPrototypeStub(@NotNull StubElement parent, @Nullable String returnType) { + public SmaliMethodPrototypeStub(@NotNull StubElement parent, @Nullable String returnSmaliTypeName) { super(parent, SmaliElementTypes.METHOD_PROTOTYPE); - this.returnType = returnType; + this.returnSmaliTypeName = returnSmaliTypeName; } - @Nullable public String getReturnType() { - return returnType; + @Nullable public String getReturnSmaliTypeName() { + return returnSmaliTypeName; } } diff --git a/smalidea/src/main/java/org/jf/smalidea/psi/stub/element/SmaliAnnotationElementType.java b/smalidea/src/main/java/org/jf/smalidea/psi/stub/element/SmaliAnnotationElementType.java index f355ab81..7085cc0e 100644 --- a/smalidea/src/main/java/org/jf/smalidea/psi/stub/element/SmaliAnnotationElementType.java +++ b/smalidea/src/main/java/org/jf/smalidea/psi/stub/element/SmaliAnnotationElementType.java @@ -62,12 +62,12 @@ public class SmaliAnnotationElementType extends SmaliStubElementType 0 && offset < javaType.length()-1) { + String left = javaType.substring(0, offset); + psiClass = facade.findClass(left, scope); + if (psiClass != null) { + psiClass = findInnerClass(psiClass, javaType.substring(offset+1, javaType.length()), facade, scope); + if (psiClass != null) { + return psiClass; + } + } + offset = javaType.indexOf('$', offset+1); + } + return null; + } + + @Nullable + public static PsiClass resolveSmaliType(@NotNull PsiElement element, @NotNull String smaliType) { + GlobalSearchScope scope = ResolveScopeManager.getElementResolveScope(element); + return resolveSmaliType(element.getProject(), scope, smaliType); + } + + @Nullable + public static PsiClass findInnerClass(@NotNull PsiClass outerClass, String innerText, JavaPsiFacade facade, + GlobalSearchScope scope) { + int offset = innerText.indexOf('$'); + if (offset < 0) { + offset = innerText.length(); + } + + while (offset > 0 && offset <= innerText.length()) { + String left = innerText.substring(0, offset); + String nextInner = outerClass.getQualifiedName() + "." + left; + PsiClass psiClass = facade.findClass(nextInner, scope); + if (psiClass != null) { + if (offset < innerText.length()) { + psiClass = findInnerClass(psiClass, innerText.substring(offset+1, innerText.length()), facade, + scope); + if (psiClass != null) { + return psiClass; + } + } else { + return psiClass; + } + } + if (offset >= innerText.length()) { + break; + } + offset = innerText.indexOf('$', offset+1); + if (offset < 0) { + offset = innerText.length(); + } + } + return null; + } + private static String simpleJavaToSmaliType(@NotNull String simpleJavaType) { StringBuilder sb = new StringBuilder(simpleJavaType.length() + 2); convertSimpleJavaToSmaliType(simpleJavaType, sb); @@ -113,6 +220,41 @@ public class NameUtils { } } + @NotNull + public static String resolveSmaliToJavaType(@NotNull Project project, @NotNull GlobalSearchScope scope, + @NotNull String smaliType) { + // First, try to resolve the type and get its qualified name, so that we can make sure + // to use the correct name for inner classes + PsiClass resolvedType = resolveSmaliType(project, scope, smaliType); + if (resolvedType != null) { + String qualifiedName = resolvedType.getQualifiedName(); + if (qualifiedName != null) { + return qualifiedName; + } + } + + // if we can't find it, just do a textual conversion of the name + return smaliToJavaType(smaliType); + } + + @NotNull + public static String resolveSmaliToJavaType(@NotNull PsiElement element, @NotNull String smaliType) { + return resolveSmaliToJavaType(element.getProject(), element.getResolveScope(), smaliType); + } + + @NotNull + public static PsiType resolveSmaliToPsiType(@NotNull PsiElement element, @NotNull String smaliType) { + PsiClass resolvedType = resolveSmaliType(element, smaliType); + if (resolvedType != null) { + PsiElementFactory factory = JavaPsiFacade.getInstance(element.getProject()).getElementFactory(); + return factory.createType(resolvedType); + } + + String javaType = NameUtils.smaliToJavaType(smaliType); + PsiElementFactory factory = JavaPsiFacade.getInstance(element.getProject()).getElementFactory(); + return factory.createTypeFromText(javaType, element); + } + @NotNull private static String convertSmaliArrayToJava(@NotNull String smaliType) { int dimensions=0; @@ -163,6 +305,9 @@ public class NameUtils { } } return; + case 'V': + dest.append("void"); + return; case 'U': if (smaliType.equals("Ujava/lang/Object;")) { dest.append("java.lang.Object"); diff --git a/smalidea/src/test/java/org/jf/smalidea/SmaliClassTypeElementTest.java b/smalidea/src/test/java/org/jf/smalidea/SmaliClassTypeElementTest.java index 7e348f12..434c959b 100644 --- a/smalidea/src/test/java/org/jf/smalidea/SmaliClassTypeElementTest.java +++ b/smalidea/src/test/java/org/jf/smalidea/SmaliClassTypeElementTest.java @@ -68,4 +68,105 @@ public class SmaliClassTypeElementTest extends LightCodeInsightFixtureTestCase { Assert.assertNotNull(resolvedClass); Assert.assertEquals("my.blarg", resolvedClass.getQualifiedName()); } + + public void testSimpleInnerClass() { + myFixture.addFileToProject("Outer.java", "" + + "public class Outer {" + + " public static class Inner {" + + " }" + + "}"); + + String text = ".class public Lsmali; " + + ".super LOuter$Inner;"; + + SmaliFile file = (SmaliFile)myFixture.addFileToProject("smali.smali", text.replace("", "")); + + SmaliClassTypeElement typeElement = + (SmaliClassTypeElement)file.findReferenceAt(text.indexOf("")); + Assert.assertNotNull(typeElement); + SmaliClassType type = typeElement.getType(); + + Assert.assertEquals("Outer.Inner", typeElement.getQualifiedName()); + Assert.assertEquals("Outer.Inner", type.getCanonicalText()); + } + + public void testInnerClassWithPackage() { + myFixture.addFileToProject("my/Outer.java", "" + + "package my;" + + "public class Outer {" + + " public static class Inner {" + + " }" + + "}"); + + String text = ".class public Lsmali; " + + ".super Lmy/Outer$Inner;"; + + SmaliFile file = (SmaliFile)myFixture.addFileToProject("smali.smali", text.replace("", "")); + + SmaliClassTypeElement typeElement = + (SmaliClassTypeElement)file.findReferenceAt(text.indexOf("")); + Assert.assertNotNull(typeElement); + SmaliClassType type = typeElement.getType(); + + Assert.assertEquals("my.Outer.Inner", typeElement.getQualifiedName()); + Assert.assertEquals("my.Outer.Inner", type.getCanonicalText()); + } + + public void testComplexInnerClass() { + myFixture.addFileToProject("my/Outer$blah.java", "" + + "package my;" + + "public class Outer$blah {" + + " public static class Inner {" + + " }" + + " public static class Inner$blah {" + + " }" + + "}"); + + String text = ".class public Lsmali; " + + ".super Lmy/Outer$blah$Inner$blah;"; + + SmaliFile file = (SmaliFile)myFixture.addFileToProject("smali.smali", text.replace("", "")); + + SmaliClassTypeElement typeElement = + (SmaliClassTypeElement)file.findReferenceAt(text.indexOf("")); + Assert.assertNotNull(typeElement); + SmaliClassType type = typeElement.getType(); + + Assert.assertEquals("my.Outer$blah.Inner$blah", typeElement.getQualifiedName()); + Assert.assertEquals("my.Outer$blah.Inner$blah", type.getCanonicalText()); + + text = ".class public Lsmali2; " + + ".super Lmy/Outer$blah$Inner;"; + + file = (SmaliFile)myFixture.addFileToProject("smali2.smali", text.replace("", "")); + + typeElement = (SmaliClassTypeElement)file.findReferenceAt(text.indexOf("")); + Assert.assertNotNull(typeElement); + type = typeElement.getType(); + + Assert.assertEquals("my.Outer$blah.Inner", typeElement.getQualifiedName()); + Assert.assertEquals("my.Outer$blah.Inner", type.getCanonicalText()); + } + + public void testInnerClassTrailingDollar() { + myFixture.addFileToProject("my/Outer$blah.java", "" + + "package my;" + + "public class Outer$ {" + + " public static class Inner$ {" + + " }" + + "}"); + + String text = ".class public Lsmali; " + + ".super Lmy/Outer$$Inner$;"; + + SmaliFile file = (SmaliFile)myFixture.addFileToProject("smali.smali", text.replace("", "")); + + SmaliClassTypeElement typeElement = + (SmaliClassTypeElement)file.findReferenceAt(text.indexOf("")); + Assert.assertNotNull(typeElement); + SmaliClassType type = typeElement.getType(); + + Assert.assertEquals("my.Outer$.Inner$", typeElement.getQualifiedName()); + Assert.assertEquals("my.Outer$.Inner$", type.getCanonicalText()); + } }