azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

JavaClass, JavaPackage, JavaAnnotation

Browse Source 
Create dumb wrappers over PSI elements, will be used for loading descriptors
from JVM reflection later (instead of PSI)
This commit is contained in:
Alexander Udalov
2013-07-29 21:44:43 +04:00
parent eaacff4566
commit de54f7d732
22 changed files with 417 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
+7 -2
View File
@@ -18,6 +18,7 @@ package org.jetbrains.jet.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder;
@@ -42,6 +43,7 @@ public class InjectorForJavaDescriptorResolver {
private final Project project;
private final BindingTrace bindingTrace;
private final JavaClassFinderImpl javaClassFinder;
private final JavaDescriptorResolver javaDescriptorResolver;
private final PsiClassFinderImpl psiClassFinder;
private final VirtualFileFinder virtualFileFinder;
@@ -65,6 +67,7 @@ public class InjectorForJavaDescriptorResolver {
) {
this.project = project;
this.bindingTrace = bindingTrace;
this.javaClassFinder = new JavaClassFinderImpl();
this.javaDescriptorResolver = new JavaDescriptorResolver();
this.psiClassFinder = new PsiClassFinderImpl();
this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class);
@@ -82,6 +85,8 @@ public class InjectorForJavaDescriptorResolver {
this.javaConstructorResolver = new JavaConstructorResolver();
this.javaPropertyResolver = new JavaPropertyResolver();
javaClassFinder.setPsiClassFinder(psiClassFinder);
this.javaDescriptorResolver.setClassResolver(javaClassResolver);
this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
@@ -92,10 +97,10 @@ public class InjectorForJavaDescriptorResolver {
javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
javaClassResolver.setFunctionResolver(javaFunctionResolver);
javaClassResolver.setJavaClassFinder(javaClassFinder);
javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
javaClassResolver.setPsiClassFinder(psiClassFinder);
javaClassResolver.setSignatureResolver(javaSignatureResolver);
javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
javaClassResolver.setTrace(bindingTrace);
@@ -128,8 +133,8 @@ public class InjectorForJavaDescriptorResolver {
annotationDescriptorDeserializer.setVirtualFileFinder(virtualFileFinder);
javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
javaNamespaceResolver.setJavaClassFinder(javaClassFinder);
javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver);
javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
javaNamespaceResolver.setTrace(bindingTrace);
javaNamespaceResolver.setVirtualFileFinder(virtualFileFinder);
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
+7 -2
View File
@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder;
import org.jetbrains.jet.lang.resolve.DeclarationResolver;
@@ -81,6 +82,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
private final JavaBridgeConfiguration javaBridgeConfiguration;
private final JavaDescriptorResolver javaDescriptorResolver;
private final PsiClassFinderImpl psiClassFinder;
private final JavaClassFinderImpl javaClassFinder;
private final NamespaceFactoryImpl namespaceFactory;
private final VirtualFileFinder virtualFileFinder;
private final DeclarationResolver declarationResolver;
@@ -133,6 +135,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
this.javaBridgeConfiguration = new JavaBridgeConfiguration();
this.javaDescriptorResolver = new JavaDescriptorResolver();
this.psiClassFinder = new PsiClassFinderImpl();
this.javaClassFinder = new JavaClassFinderImpl();
this.namespaceFactory = new NamespaceFactoryImpl();
this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class);
this.declarationResolver = new DeclarationResolver();
@@ -208,6 +211,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
psiClassFinder.setProject(project);
javaClassFinder.setPsiClassFinder(psiClassFinder);
this.namespaceFactory.setModuleDescriptor(moduleDescriptor);
this.namespaceFactory.setTrace(bindingTrace);
@@ -279,10 +284,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
javaClassResolver.setFunctionResolver(javaFunctionResolver);
javaClassResolver.setJavaClassFinder(javaClassFinder);
javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
javaClassResolver.setPsiClassFinder(psiClassFinder);
javaClassResolver.setSignatureResolver(javaSignatureResolver);
javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
javaClassResolver.setTrace(bindingTrace);
@@ -315,8 +320,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
annotationDescriptorDeserializer.setVirtualFileFinder(virtualFileFinder);
javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
javaNamespaceResolver.setJavaClassFinder(javaClassFinder);
javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver);
javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
javaNamespaceResolver.setTrace(bindingTrace);
javaNamespaceResolver.setVirtualFileFinder(virtualFileFinder);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java
+20 -24
View File
@@ -23,6 +23,7 @@ import com.intellij.psi.util.PsiFormatUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.JetType;
@@ -38,33 +39,29 @@ public final class DescriptorResolverUtils {
private DescriptorResolverUtils() {
}
public static boolean isCompiledKotlinPackageClass(@NotNull PsiClass psiClass) {
if (psiClass instanceof ClsClassImpl) {
String qualifiedName = psiClass.getQualifiedName();
if (qualifiedName != null && PackageClassUtils.isPackageClassFqName(new FqName(qualifiedName))) {
return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName());
public static boolean isCompiledKotlinPackageClass(@NotNull JavaClass javaClass) {
if (javaClass.getPsiClass() instanceof ClsClassImpl) {
String fqName = javaClass.getFqName();
if (fqName != null && PackageClassUtils.isPackageClassFqName(new FqName(fqName))) {
return hasAnnotation(javaClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName());
}
}
return false;
}
public static boolean isCompiledKotlinClass(@NotNull PsiClass psiClass) {
if (psiClass instanceof ClsClassImpl) {
return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName());
public static boolean isCompiledKotlinClass(@NotNull JavaClass javaClass) {
if (javaClass.getPsiClass() instanceof ClsClassImpl) {
return hasAnnotation(javaClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName());
}
return false;
}
public static boolean hasAnnotation(@NotNull PsiClass psiClass, @NotNull FqName annotationFqName) {
PsiModifierList list = psiClass.getModifierList();
if (list != null) {
return list.findAnnotation(annotationFqName.asString()) != null;
}
return false;
public static boolean hasAnnotation(@NotNull JavaClass javaClass, @NotNull FqName annotationFqName) {
return javaClass.findAnnotation(annotationFqName.asString()) != null;
}
public static boolean isCompiledKotlinClassOrPackageClass(@NotNull PsiClass psiClass) {
return isCompiledKotlinClass(psiClass) || isCompiledKotlinPackageClass(psiClass);
public static boolean isCompiledKotlinClassOrPackageClass(@NotNull JavaClass javaClass) {
return isCompiledKotlinClass(javaClass) || isCompiledKotlinPackageClass(javaClass);
}
@NotNull
@@ -155,15 +152,14 @@ public final class DescriptorResolverUtils {
}
@NotNull
public static Collection<PsiClass> filterDuplicateClasses(@NotNull PsiClass[] classes) {
Set<String> addedQualifiedNames = new HashSet<String>(classes.length);
List<PsiClass> result = new ArrayList<PsiClass>(classes.length);
public static Collection<JavaClass> filterDuplicateClasses(@NotNull Collection<JavaClass> classes) {
Set<String> addedQualifiedNames = new HashSet<String>(classes.size());
List<JavaClass> result = new ArrayList<JavaClass>(classes.size());
for (PsiClass psiClass : classes) {
String qualifiedName = psiClass.getQualifiedName();
if (qualifiedName != null && addedQualifiedNames.add(qualifiedName)) {
result.add(psiClass);
for (JavaClass javaClass : classes) {
String fqName = javaClass.getFqName();
if (fqName != null && addedQualifiedNames.add(fqName)) {
result.add(javaClass);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinder.java
+32
View File
@@ -0,0 +1,32 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.name.FqName;
public interface JavaClassFinder {
// TODO: scope
@Nullable
JavaClass findClass(@NotNull FqName fqName);
@Nullable
JavaPackage findPackage(@NotNull FqName fqName);
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java
+50
View File
@@ -0,0 +1,50 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.name.FqName;
import javax.inject.Inject;
public class JavaClassFinderImpl implements JavaClassFinder {
private PsiClassFinder psiClassFinder;
@Inject
public void setPsiClassFinder(@NotNull PsiClassFinder psiClassFinder) {
this.psiClassFinder = psiClassFinder;
}
@Nullable
@Override
public JavaClass findClass(@NotNull FqName fqName) {
PsiClass psiClass = psiClassFinder.findPsiClass(fqName);
return psiClass == null ? null : new JavaClass(psiClass);
}
@Nullable
@Override
public JavaPackage findPackage(@NotNull FqName fqName) {
PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName);
return psiPackage == null ? null : new JavaPackage(psiPackage);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+3 -3
View File
@@ -16,12 +16,12 @@
package org.jetbrains.jet.lang.resolve.java;
import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
import org.jetbrains.jet.lang.resolve.java.resolver.*;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -81,8 +81,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
}
@NotNull
public Collection<ConstructorDescriptor> resolveConstructors(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor) {
return constructorResolver.resolveConstructors(psiClass, classDescriptor);
public Collection<ConstructorDescriptor> resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor classDescriptor) {
return constructorResolver.resolveConstructors(javaClass, classDescriptor);
}
@Nullable
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java
+21 -14
View File
@@ -18,12 +18,17 @@ package org.jetbrains.jet.lang.resolve.java.provider;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import com.intellij.psi.*;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiMember;
import com.intellij.psi.PsiMethod;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiFieldWrapper;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
@@ -89,19 +94,19 @@ public final class MembersCache {
@NotNull
public static MembersCache buildMembersByNameCache(
@Nullable PsiClass psiClass,
@Nullable PsiPackage psiPackage,
@Nullable JavaClass javaClass,
@Nullable JavaPackage javaPackage,
boolean staticMembers
) {
MembersCache membersCache = new MembersCache();
if (psiClass != null) {
membersCache.new ClassMemberProcessor(psiClass, staticMembers).process();
Collection<PsiClass> innerClasses = DescriptorResolverUtils.filterDuplicateClasses(psiClass.getInnerClasses());
if (javaClass != null) {
membersCache.new ClassMemberProcessor(javaClass, staticMembers).process();
Collection<JavaClass> innerClasses = javaClass.getInnerClasses();
membersCache.new ExtraPackageMembersProcessor(innerClasses).process();
}
else if (psiPackage != null) {
Collection<PsiClass> classes = DescriptorResolverUtils.filterDuplicateClasses(psiPackage.getClasses());
else if (javaPackage != null) {
Collection<JavaClass> classes = DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses());
membersCache.new ExtraPackageMembersProcessor(classes).process();
}
@@ -110,14 +115,16 @@ public final class MembersCache {
private class ExtraPackageMembersProcessor { // 'extra' means that PSI elements for these members are not just top-level classes
@NotNull
private final Collection<PsiClass> psiClasses;
private final Collection<JavaClass> javaClasses;
private ExtraPackageMembersProcessor(@NotNull Collection<PsiClass> psiClasses) {
this.psiClasses = psiClasses;
private ExtraPackageMembersProcessor(@NotNull Collection<JavaClass> javaClasses) {
this.javaClasses = javaClasses;
}
private void process() {
for (PsiClass psiClass : psiClasses) {
for (JavaClass javaClass : javaClasses) {
PsiClass psiClass = javaClass.getPsiClass();
if (!(psiClass instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses
if (SingleAbstractMethodUtils.isSamInterface(psiClass)) {
processSamInterface(psiClass);
@@ -137,8 +144,8 @@ public final class MembersCache {
private final PsiClass psiClass;
private final boolean staticMembers;
private ClassMemberProcessor(@NotNull PsiClass psiClass, boolean staticMembers) {
this.psiClass = psiClass;
private ClassMemberProcessor(@NotNull JavaClass javaClass, boolean staticMembers) {
this.psiClass = javaClass.getPsiClass();
this.staticMembers = staticMembers;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
+20 -22
View File
@@ -22,7 +22,6 @@ import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifier;
@@ -39,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -91,7 +91,7 @@ public final class JavaClassResolver {
private JavaSignatureResolver signatureResolver;
private JavaDescriptorResolver javaDescriptorResolver;
private JavaAnnotationResolver annotationResolver;
private PsiClassFinder psiClassFinder;
private JavaClassFinder javaClassFinder;
private JavaNamespaceResolver namespaceResolver;
private JavaSupertypeResolver supertypesResolver;
private JavaFunctionResolver functionResolver;
@@ -132,8 +132,8 @@ public final class JavaClassResolver {
}
@Inject
public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
this.psiClassFinder = psiClassFinder;
public void setJavaClassFinder(JavaClassFinder javaClassFinder) {
this.javaClassFinder = javaClassFinder;
}
@Inject
@@ -237,17 +237,14 @@ public final class JavaClassResolver {
}
}
PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName);
if (psiClass == null) {
JavaClass javaClass = javaClassFinder.findClass(qualifiedName);
if (javaClass == null) {
cacheNegativeValue(javaClassToKotlinFqName(qualifiedName));
return null;
}
if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) {
PsiAnnotation assertInvisibleAnnotation = JavaAnnotationResolver.findOwnAnnotation(
psiClass, JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString());
if (assertInvisibleAnnotation != null) {
if (javaClass.findAnnotation(JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString()) != null) {
if (ApplicationManager.getApplication().isInternal()) {
LOG.error("classpath is configured incorrectly:" +
" class " + qualifiedName + " from runtime must not be loaded by compiler");
@@ -257,10 +254,12 @@ public final class JavaClassResolver {
}
// Class may have been resolved previously by different Java resolver instance, and we are reusing its trace
ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, psiClass);
ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, javaClass.getPsiClass());
if (alreadyResolved != null) {
return alreadyResolved;
}
PsiClass psiClass = javaClass.getPsiClass();
//TODO: code duplication
ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(qualifiedName, isContainedInClass(psiClass));
// class may be resolved during resolution of parent
@@ -275,7 +274,7 @@ public final class JavaClassResolver {
checkPsiClassIsNotJet(psiClass);
return doCreateClassDescriptor(qualifiedName, psiClass, tasks, containingDeclaration);
return doCreateClassDescriptor(qualifiedName, javaClass, tasks, containingDeclaration);
}
private void cacheNegativeValue(@NotNull FqNameBase qualifiedName) {
@@ -293,10 +292,12 @@ public final class JavaClassResolver {
@NotNull
private ClassDescriptorFromJvmBytecode doCreateClassDescriptor(
@NotNull FqName fqName,
@NotNull PsiClass psiClass,
@NotNull JavaClass javaClass,
@NotNull PostponedTasks taskList,
@NotNull ClassOrNamespaceDescriptor containingDeclaration
) {
PsiClass psiClass = javaClass.getPsiClass();
ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(containingDeclaration, getClassKind(psiClass),
isInnerClass(psiClass));
@@ -314,7 +315,7 @@ public final class JavaClassResolver {
classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
classDescriptor.createTypeConstructor();
JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, psiClass, false, javaDescriptorResolver);
JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, javaClass, false, javaDescriptorResolver);
classDescriptor.setScopeForMemberLookup(scope);
classDescriptor.setScopeForConstructorResolve(scope);
@@ -326,7 +327,7 @@ public final class JavaClassResolver {
supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, psiClass, classTypeParameters));
if (psiClass.isEnum()) {
ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass);
ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, javaClass);
cache(getFqNameForClassObject(psiClass), classObjectDescriptor);
classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
}
@@ -497,11 +498,8 @@ public final class JavaClassResolver {
}
@NotNull
private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
@NotNull ClassDescriptor containing,
@NotNull PsiClass psiClass
) {
ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(@NotNull ClassDescriptor containing, @NotNull JavaClass javaClass) {
ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, javaClass);
classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
@@ -510,7 +508,7 @@ public final class JavaClassResolver {
}
@NotNull
private ClassDescriptorFromJvmBytecode createSyntheticClassObject(@NotNull ClassDescriptor containing, @NotNull PsiClass psiClass) {
private ClassDescriptorFromJvmBytecode createSyntheticClassObject(@NotNull ClassDescriptor containing, @NotNull JavaClass javaClass) {
ClassDescriptorFromJvmBytecode classObjectDescriptor =
new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
@@ -520,7 +518,7 @@ public final class JavaClassResolver {
classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
classObjectDescriptor.createTypeConstructor();
JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, psiClass, true,
JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, javaClass, true,
javaDescriptorResolver);
WritableScopeImpl writableScope =
new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java
+4 -1
View File
@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.JetType;
@@ -67,7 +68,9 @@ public final class JavaConstructorResolver {
}
@NotNull
public Collection<ConstructorDescriptor> resolveConstructors(@NotNull PsiClass psiClass, @NotNull ClassDescriptor containingClass) {
public Collection<ConstructorDescriptor> resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor containingClass) {
PsiClass psiClass = javaClass.getPsiClass();
Collection<ConstructorDescriptor> constructors = Lists.newArrayList();
List<TypeParameterDescriptor> typeParameters = containingClass.getTypeConstructor().getParameters();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java
+22 -19
View File
@@ -22,7 +22,6 @@ import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMember;
import com.intellij.psi.PsiModifier;
import com.intellij.psi.PsiPackage;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -40,6 +39,8 @@ import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -61,7 +62,7 @@ public final class JavaNamespaceResolver {
@NotNull
private final Set<FqName> unresolvedCache = Sets.newHashSet();
private PsiClassFinder psiClassFinder;
private JavaClassFinder javaClassFinder;
private BindingTrace trace;
private JavaDescriptorResolver javaDescriptorResolver;
@@ -77,8 +78,8 @@ public final class JavaNamespaceResolver {
}
@Inject
public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
this.psiClassFinder = psiClassFinder;
public void setJavaClassFinder(JavaClassFinder javaClassFinder) {
this.javaClassFinder = javaClassFinder;
}
@Inject
@@ -156,8 +157,8 @@ public final class JavaNamespaceResolver {
@NotNull NamespaceDescriptor namespaceDescriptor,
boolean record
) {
PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName);
if (psiPackage != null) {
JavaPackage javaPackage = javaClassFinder.findPackage(fqName);
if (javaPackage != null) {
FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName);
VirtualFile virtualFile = virtualFileFinder.find(packageClassFqName);
@@ -175,19 +176,21 @@ public final class JavaNamespaceResolver {
// Otherwise (if psiClass is null or doesn't have a supported Kotlin annotation), it's a Java class and the package is empty
if (record) {
trace.record(BindingContext.NAMESPACE, psiPackage, namespaceDescriptor);
trace.record(BindingContext.NAMESPACE, javaPackage.getPsiPackage(), namespaceDescriptor);
}
return new JavaPackageScope(namespaceDescriptor, psiPackage, fqName, javaDescriptorResolver);
return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, javaDescriptorResolver);
}
PsiClass psiClass = psiClassFinder.findPsiClass(fqName);
if (psiClass == null) {
JavaClass javaClass = javaClassFinder.findClass(fqName);
if (javaClass == null) {
return null;
}
if (DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(psiClass)) {
if (DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(javaClass)) {
return null;
}
PsiClass psiClass = javaClass.getPsiClass();
if (!hasStaticMembers(psiClass)) {
return null;
}
@@ -198,7 +201,7 @@ public final class JavaNamespaceResolver {
trace.record(BindingContext.NAMESPACE, psiClass, namespaceDescriptor);
}
return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, psiClass, javaDescriptorResolver);
return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, javaDescriptorResolver);
}
private void cache(@NotNull FqName fqName, @Nullable JetScope packageScope) {
@@ -248,14 +251,14 @@ public final class JavaNamespaceResolver {
@NotNull
public Collection<Name> getClassNamesInPackage(@NotNull FqName packageName) {
PsiPackage psiPackage = psiClassFinder.findPsiPackage(packageName);
if (psiPackage == null) return Collections.emptyList();
JavaPackage javaPackage = javaClassFinder.findPackage(packageName);
if (javaPackage == null) return Collections.emptyList();
PsiClass[] classes = psiPackage.getClasses();
List<Name> result = new ArrayList<Name>(classes.length);
for (PsiClass psiClass : classes) {
if (DescriptorResolverUtils.isCompiledKotlinClass(psiClass)) {
result.add(Name.identifier(psiClass.getName()));
Collection<JavaClass> classes = DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses());
List<Name> result = new ArrayList<Name>(classes.size());
for (JavaClass javaClass : classes) {
if (DescriptorResolverUtils.isCompiledKotlinClass(javaClass)) {
result.add(Name.identifier(javaClass.getName()));
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java
+13 -13
View File
@@ -16,12 +16,12 @@
package org.jetbrains.jet.lang.resolve.java.scope;
import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.name.FqName;
import java.util.ArrayList;
@@ -37,18 +37,18 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
@NotNull
private final ClassDescriptor descriptor;
@NotNull
private final PsiClass psiClass;
private final JavaClass javaClass;
private final boolean staticMembersOfPsiClass;
public JavaClassNonStaticMembersScope(
@NotNull ClassDescriptor descriptor,
@NotNull PsiClass psiClass,
@NotNull JavaClass javaClass,
boolean staticMembersOfPsiClass,
@NotNull JavaDescriptorResolver javaDescriptorResolver
) {
super(descriptor, MembersProvider.forClass(psiClass, staticMembersOfPsiClass), javaDescriptorResolver);
super(descriptor, MembersProvider.forClass(javaClass, staticMembersOfPsiClass), javaDescriptorResolver);
this.descriptor = descriptor;
this.psiClass = psiClass;
this.javaClass = javaClass;
this.staticMembersOfPsiClass = staticMembersOfPsiClass;
}
@@ -67,7 +67,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
private void initConstructorsIfNeeded() {
if (constructors == null) {
constructors = javaDescriptorResolver.resolveConstructors(psiClass, descriptor);
constructors = javaDescriptorResolver.resolveConstructors(javaClass, descriptor);
for (ConstructorDescriptor constructor : constructors) {
if (constructor.isPrimary()) {
@@ -88,18 +88,18 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
return Collections.emptyList();
}
PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
for (PsiClass innerPsiClass : innerPsiClasses) {
result.add(resolveInnerClass(innerPsiClass));
Collection<JavaClass> innerClasses = javaClass.getInnerClasses();
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerClasses.size());
for (JavaClass innerClass : innerClasses) {
result.add(resolveInnerClass(innerClass));
}
return result;
}
@NotNull
private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {
String name = innerPsiClass.getQualifiedName();
assert name != null : "Inner class has no qualified name: " + innerPsiClass;
private ClassDescriptor resolveInnerClass(@NotNull JavaClass innerClass) {
String name = innerClass.getFqName();
assert name != null : "Inner class has no qualified name: " + innerClass;
ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName(name), IGNORE_KOTLIN_SOURCES);
assert classDescriptor != null : "Couldn't resolve inner class " + name;
return classDescriptor;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java
+6 -6
View File
@@ -16,13 +16,13 @@
package org.jetbrains.jet.lang.resolve.java.scope;
import com.intellij.psi.PsiClass;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -35,17 +35,17 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
@NotNull
private final FqName packageFQN;
@NotNull
private final PsiClass psiClass;
private final JavaClass javaClass;
public JavaClassStaticMembersScope(
@NotNull NamespaceDescriptor descriptor,
@NotNull FqName packageFQN,
@NotNull PsiClass psiClass,
@NotNull JavaClass javaClass,
@NotNull JavaDescriptorResolver javaDescriptorResolver
) {
super(descriptor, MembersProvider.forClass(psiClass, true), javaDescriptorResolver);
super(descriptor, MembersProvider.forClass(javaClass, true), javaDescriptorResolver);
this.packageFQN = packageFQN;
this.psiClass = psiClass;
this.javaClass = javaClass;
}
@Override
@@ -57,7 +57,7 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
@Override
protected Collection<DeclarationDescriptor> computeAllDescriptors() {
Collection<DeclarationDescriptor> result = super.computeAllDescriptors();
for (PsiClass nested : psiClass.getInnerClasses()) {
for (JavaClass nested : javaClass.getInnerClasses()) {
ContainerUtil.addIfNotNull(result, getNamespace(Name.identifier(nested.getName())));
}
return result;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java
+17 -13
View File
@@ -18,15 +18,15 @@ package org.jetbrains.jet.lang.resolve.java.scope;
import com.google.common.collect.Sets;
import com.intellij.openapi.progress.ProgressIndicatorProvider;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiModifier;
import com.intellij.psi.PsiPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -39,18 +39,18 @@ import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_K
public final class JavaPackageScope extends JavaBaseScope {
@NotNull
private final PsiPackage psiPackage;
private final JavaPackage javaPackage;
@NotNull
private final FqName packageFQN;
public JavaPackageScope(
@NotNull NamespaceDescriptor descriptor,
@NotNull PsiPackage psiPackage,
@NotNull JavaPackage javaPackage,
@NotNull FqName packageFQN,
@NotNull JavaDescriptorResolver javaDescriptorResolver
) {
super(descriptor, javaDescriptorResolver, MembersProvider.forPackage(psiPackage));
this.psiPackage = psiPackage;
super(descriptor, javaDescriptorResolver, MembersProvider.forPackage(javaPackage));
this.javaPackage = javaPackage;
this.packageFQN = packageFQN;
}
@@ -89,24 +89,24 @@ public final class JavaPackageScope extends JavaBaseScope {
private Collection<DeclarationDescriptor> computeAllPackageDeclarations() {
Collection<DeclarationDescriptor> result = Sets.newHashSet();
for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) {
FqName fqName = new FqName(psiSubPackage.getQualifiedName());
for (JavaPackage subPackage : javaPackage.getSubPackages()) {
FqName fqName = new FqName(subPackage.getFqName());
NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES);
if (childNs != null) {
result.add(childNs);
}
}
for (PsiClass psiClass : DescriptorResolverUtils.filterDuplicateClasses(psiPackage.getClasses())) {
if (DescriptorResolverUtils.isCompiledKotlinPackageClass(psiClass)) continue;
for (JavaClass javaClass : DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses())) {
if (DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass)) continue;
if (psiClass instanceof JetJavaMirrorMarker) continue;
if (isKotlinLightClass(javaClass)) continue;
if (!psiClass.hasModifierProperty(PsiModifier.PUBLIC)) continue;
if (!javaClass.getPsiClass().hasModifierProperty(PsiModifier.PUBLIC)) continue;
ProgressIndicatorProvider.checkCanceled();
String qualifiedName = psiClass.getQualifiedName();
String qualifiedName = javaClass.getFqName();
if (qualifiedName == null) continue;
FqName fqName = new FqName(qualifiedName);
@@ -124,6 +124,10 @@ public final class JavaPackageScope extends JavaBaseScope {
return result;
}
private static boolean isKotlinLightClass(@NotNull JavaClass javaClass) {
return javaClass.getPsiClass() instanceof JetJavaMirrorMarker;
}
@Override
@NotNull
protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java
+12 -12
View File
@@ -16,37 +16,37 @@
package org.jetbrains.jet.lang.resolve.java.scope;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.provider.MembersCache;
import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
import org.jetbrains.jet.lang.resolve.name.Name;
import java.util.Collection;
/* package */ class MembersProvider {
@Nullable
private final PsiClass psiClass;
private final JavaClass javaClass;
@Nullable
private final PsiPackage psiPackage;
private final JavaPackage javaPackage;
private final boolean staticMembers;
private MembersProvider(@Nullable PsiClass psiClass, @Nullable PsiPackage psiPackage, boolean staticMembers) {
this.psiClass = psiClass;
this.psiPackage = psiPackage;
private MembersProvider(@Nullable JavaClass javaClass, @Nullable JavaPackage javaPackage, boolean staticMembers) {
this.javaClass = javaClass;
this.javaPackage = javaPackage;
this.staticMembers = staticMembers;
}
@NotNull
public static MembersProvider forPackage(@NotNull PsiPackage psiPackage) {
return new MembersProvider(null, psiPackage, true);
public static MembersProvider forPackage(@NotNull JavaPackage javaPackage) {
return new MembersProvider(null, javaPackage, true);
}
@NotNull
public static MembersProvider forClass(@NotNull PsiClass psiClass, boolean staticMembers) {
return new MembersProvider(psiClass, null, staticMembers);
public static MembersProvider forClass(@NotNull JavaClass javaClass, boolean staticMembers) {
return new MembersProvider(javaClass, null, staticMembers);
}
@Nullable
@@ -63,7 +63,7 @@ import java.util.Collection;
@NotNull
private MembersCache getMembersCache() {
if (membersCache == null) {
membersCache = MembersCache.buildMembersByNameCache(psiClass, psiPackage, staticMembers);
membersCache = MembersCache.buildMembersByNameCache(javaClass, javaPackage, staticMembers);
}
return membersCache;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaAnnotation.java
+28
View File
@@ -0,0 +1,28 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java.structure;
import com.intellij.psi.PsiAnnotation;
import org.jetbrains.annotations.NotNull;
public class JavaAnnotation {
private final PsiAnnotation psiAnnotation;
public JavaAnnotation(@NotNull PsiAnnotation psiAnnotation) {
this.psiAnnotation = psiAnnotation;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java
+76
View File
@@ -0,0 +1,76 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java.structure;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiModifierList;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class JavaClass {
private final PsiClass psiClass;
public JavaClass(@NotNull PsiClass psiClass) {
this.psiClass = psiClass;
}
@NotNull
public PsiClass getPsiClass() {
return psiClass;
}
@NotNull
/* package */ static Collection<JavaClass> javaClassesFromPsi(@NotNull PsiClass[] classes) {
List<JavaClass> result = new ArrayList<JavaClass>(classes.length);
for (PsiClass psiClass : classes) {
result.add(new JavaClass(psiClass));
}
return result;
}
@NotNull
public Collection<JavaClass> getInnerClasses() {
return javaClassesFromPsi(psiClass.getInnerClasses());
}
@Nullable
public String getFqName() {
return psiClass.getQualifiedName();
}
@Nullable
public JavaAnnotation findAnnotation(@NotNull String fqName) {
PsiModifierList modifierList = psiClass.getModifierList();
if (modifierList != null) {
PsiAnnotation annotation = modifierList.findAnnotation(fqName);
if (annotation != null) {
return new JavaAnnotation(annotation);
}
}
return null;
}
@NotNull
public String getName() {
return psiClass.getName();
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPackage.java
+67
View File
@@ -0,0 +1,67 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java.structure;
import com.intellij.psi.PsiPackage;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class JavaPackage {
private final PsiPackage psiPackage;
public JavaPackage(@NotNull PsiPackage psiPackage) {
this.psiPackage = psiPackage;
}
@NotNull
public PsiPackage getPsiPackage() {
return psiPackage;
}
@NotNull
private static Collection<JavaPackage> javaPackagesFromPsi(@NotNull PsiPackage[] packages) {
List<JavaPackage> result = new ArrayList<JavaPackage>(packages.length);
for (PsiPackage psiPackage : packages) {
result.add(new JavaPackage(psiPackage));
}
return result;
}
@NotNull
public Collection<JavaClass> getClasses() {
return JavaClass.javaClassesFromPsi(psiPackage.getClasses());
}
@NotNull
public Collection<JavaPackage> getSubPackages() {
return javaPackagesFromPsi(psiPackage.getSubPackages());
}
@NotNull
public String getFqName() {
return psiPackage.getQualifiedName();
}
@NotNull
public String getName() {
String name = psiPackage.getName();
return name == null ? "" : name;
}
}