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

Remove big chunk of code related to using old annotations

Browse Source
This commit is contained in:
Pavel V. Talanov
2013-07-05 14:09:45 +04:00
committed by Alexander Udalov
parent 60619a3507
commit 69295290eb
32 changed files with 255 additions and 1136 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
+7 -16
View File
@@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
@@ -37,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv
import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
@@ -58,8 +57,6 @@ public class InjectorForJavaDescriptorResolver {
private final JavaClassResolver javaClassResolver;
private final JavaAnnotationResolver javaAnnotationResolver;
private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
private final JavaClassObjectResolver javaClassObjectResolver;
private final JavaSupertypeResolver javaSupertypeResolver;
private final JavaFunctionResolver javaFunctionResolver;
private final JavaValueParameterResolver javaValueParameterResolver;
private final JavaSignatureResolver javaSignatureResolver;
@@ -67,6 +64,7 @@ public class InjectorForJavaDescriptorResolver {
private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
private final ErrorReporter errorReporter;
private final JavaNamespaceResolver javaNamespaceResolver;
private final JavaSupertypeResolver javaSupertypeResolver;
private final JavaConstructorResolver javaConstructorResolver;
private final JavaInnerClassResolver javaInnerClassResolver;
private final JavaPropertyResolver javaPropertyResolver;
@@ -88,8 +86,6 @@ public class InjectorForJavaDescriptorResolver {
this.javaClassResolver = new JavaClassResolver();
this.javaAnnotationResolver = new JavaAnnotationResolver();
this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
this.javaClassObjectResolver = new JavaClassObjectResolver();
this.javaSupertypeResolver = new JavaSupertypeResolver();
this.javaFunctionResolver = new JavaFunctionResolver();
this.javaValueParameterResolver = new JavaValueParameterResolver();
this.javaSignatureResolver = new JavaSignatureResolver();
@@ -97,6 +93,7 @@ public class InjectorForJavaDescriptorResolver {
this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
this.errorReporter = new ErrorReporter();
this.javaNamespaceResolver = new JavaNamespaceResolver();
this.javaSupertypeResolver = new JavaSupertypeResolver();
this.javaConstructorResolver = new JavaConstructorResolver();
this.javaInnerClassResolver = new JavaInnerClassResolver();
this.javaPropertyResolver = new JavaPropertyResolver();
@@ -122,7 +119,6 @@ public class InjectorForJavaDescriptorResolver {
javaTypeTransformer.setResolver(javaDescriptorResolver);
javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
javaClassResolver.setFunctionResolver(javaFunctionResolver);
javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
@@ -138,15 +134,6 @@ public class InjectorForJavaDescriptorResolver {
javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
javaClassObjectResolver.setSemanticServices(javaSemanticServices);
javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
javaClassObjectResolver.setTrace(bindingTrace);
javaSupertypeResolver.setClassResolver(javaClassResolver);
javaSupertypeResolver.setSemanticServices(javaSemanticServices);
javaSupertypeResolver.setTrace(bindingTrace);
javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
@@ -172,6 +159,10 @@ public class InjectorForJavaDescriptorResolver {
javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
javaNamespaceResolver.setTrace(bindingTrace);
javaSupertypeResolver.setClassResolver(javaClassResolver);
javaSupertypeResolver.setTrace(bindingTrace);
javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
javaConstructorResolver.setTrace(bindingTrace);
javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java
+7 -16
View File
@@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
@@ -37,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv
import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
@@ -58,8 +57,6 @@ public class InjectorForJavaSemanticServices {
private final JavaClassResolver javaClassResolver;
private final JavaAnnotationResolver javaAnnotationResolver;
private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
private final JavaClassObjectResolver javaClassObjectResolver;
private final JavaSupertypeResolver javaSupertypeResolver;
private final JavaFunctionResolver javaFunctionResolver;
private final JavaValueParameterResolver javaValueParameterResolver;
private final JavaSignatureResolver javaSignatureResolver;
@@ -67,6 +64,7 @@ public class InjectorForJavaSemanticServices {
private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
private final ErrorReporter errorReporter;
private final JavaNamespaceResolver javaNamespaceResolver;
private final JavaSupertypeResolver javaSupertypeResolver;
private final JavaConstructorResolver javaConstructorResolver;
private final JavaInnerClassResolver javaInnerClassResolver;
private final JavaPropertyResolver javaPropertyResolver;
@@ -86,8 +84,6 @@ public class InjectorForJavaSemanticServices {
this.javaClassResolver = new JavaClassResolver();
this.javaAnnotationResolver = new JavaAnnotationResolver();
this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
this.javaClassObjectResolver = new JavaClassObjectResolver();
this.javaSupertypeResolver = new JavaSupertypeResolver();
this.javaFunctionResolver = new JavaFunctionResolver();
this.javaValueParameterResolver = new JavaValueParameterResolver();
this.javaSignatureResolver = new JavaSignatureResolver();
@@ -95,6 +91,7 @@ public class InjectorForJavaSemanticServices {
this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
this.errorReporter = new ErrorReporter();
this.javaNamespaceResolver = new JavaNamespaceResolver();
this.javaSupertypeResolver = new JavaSupertypeResolver();
this.javaConstructorResolver = new JavaConstructorResolver();
this.javaInnerClassResolver = new JavaInnerClassResolver();
this.javaPropertyResolver = new JavaPropertyResolver();
@@ -122,7 +119,6 @@ public class InjectorForJavaSemanticServices {
javaTypeTransformer.setResolver(javaDescriptorResolver);
javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
javaClassResolver.setFunctionResolver(javaFunctionResolver);
javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
@@ -138,15 +134,6 @@ public class InjectorForJavaSemanticServices {
javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
javaClassObjectResolver.setSemanticServices(javaSemanticServices);
javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
javaClassObjectResolver.setTrace(bindingTrace);
javaSupertypeResolver.setClassResolver(javaClassResolver);
javaSupertypeResolver.setSemanticServices(javaSemanticServices);
javaSupertypeResolver.setTrace(bindingTrace);
javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
@@ -172,6 +159,10 @@ public class InjectorForJavaSemanticServices {
javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
javaNamespaceResolver.setTrace(bindingTrace);
javaSupertypeResolver.setClassResolver(javaClassResolver);
javaSupertypeResolver.setTrace(bindingTrace);
javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
javaConstructorResolver.setTrace(bindingTrace);
javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
+7 -16
View File
@@ -53,8 +53,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
@@ -62,6 +60,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolv
import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
@@ -108,8 +107,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
private final JavaClassResolver javaClassResolver;
private final JavaAnnotationResolver javaAnnotationResolver;
private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
private final JavaClassObjectResolver javaClassObjectResolver;
private final JavaSupertypeResolver javaSupertypeResolver;
private final JavaFunctionResolver javaFunctionResolver;
private final JavaValueParameterResolver javaValueParameterResolver;
private final JavaSignatureResolver javaSignatureResolver;
@@ -117,6 +114,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
private final ErrorReporter errorReporter;
private final JavaNamespaceResolver javaNamespaceResolver;
private final JavaSupertypeResolver javaSupertypeResolver;
private final JavaConstructorResolver javaConstructorResolver;
private final JavaInnerClassResolver javaInnerClassResolver;
private final JavaPropertyResolver javaPropertyResolver;
@@ -164,8 +162,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
this.javaClassResolver = new JavaClassResolver();
this.javaAnnotationResolver = new JavaAnnotationResolver();
this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
this.javaClassObjectResolver = new JavaClassObjectResolver();
this.javaSupertypeResolver = new JavaSupertypeResolver();
this.javaFunctionResolver = new JavaFunctionResolver();
this.javaValueParameterResolver = new JavaValueParameterResolver();
this.javaSignatureResolver = new JavaSignatureResolver();
@@ -173,6 +169,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
this.errorReporter = new ErrorReporter();
this.javaNamespaceResolver = new JavaNamespaceResolver();
this.javaSupertypeResolver = new JavaSupertypeResolver();
this.javaConstructorResolver = new JavaConstructorResolver();
this.javaInnerClassResolver = new JavaInnerClassResolver();
this.javaPropertyResolver = new JavaPropertyResolver();
@@ -300,7 +297,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
javaTypeTransformer.setResolver(javaDescriptorResolver);
javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
javaClassResolver.setClassObjectResolver(javaClassObjectResolver);
javaClassResolver.setFunctionResolver(javaFunctionResolver);
javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
@@ -316,15 +312,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
javaClassObjectResolver.setSemanticServices(javaSemanticServices);
javaClassObjectResolver.setSupertypesResolver(javaSupertypeResolver);
javaClassObjectResolver.setTrace(bindingTrace);
javaSupertypeResolver.setClassResolver(javaClassResolver);
javaSupertypeResolver.setSemanticServices(javaSemanticServices);
javaSupertypeResolver.setTrace(bindingTrace);
javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
@@ -350,6 +337,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
javaNamespaceResolver.setTrace(bindingTrace);
javaSupertypeResolver.setClassResolver(javaClassResolver);
javaSupertypeResolver.setTrace(bindingTrace);
javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
javaConstructorResolver.setTrace(bindingTrace);
javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java
+3 -33
View File
@@ -23,9 +23,6 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.constants.StringValue;
import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -63,36 +60,9 @@ public final class DescriptorResolverUtils {
return Collections.emptyList();
}
public static Modality resolveModality(PsiMemberWrapper memberWrapper, boolean isFinal) {
if (memberWrapper instanceof PsiMethodWrapper) {
PsiMethodWrapper method = (PsiMethodWrapper) memberWrapper;
if (method.getJetMethodAnnotation().hasForceOpenFlag()) {
return Modality.OPEN;
}
if (method.getJetMethodAnnotation().hasForceFinalFlag()) {
return Modality.FINAL;
}
}
return Modality.convertFromFlags(memberWrapper.isAbstract(), !isFinal);
}
public static Visibility resolveVisibility(
@NotNull PsiModifierListOwner modifierListOwner,
@Nullable PsiAnnotationWithFlags annotation
@NotNull PsiModifierListOwner modifierListOwner
) {
if (annotation != null) {
if (annotation.hasPrivateFlag()) {
return Visibilities.PRIVATE;
}
else if (annotation.hasInternalFlag()) {
return Visibilities.INTERNAL;
}
else if (annotation.hasProtectedFlag()) {
return Visibilities.PROTECTED;
}
}
if (modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC)) {
return Visibilities.PUBLIC;
}
@@ -159,7 +129,7 @@ public final class DescriptorResolverUtils {
/**
* @return true if {@code member} is a static member of enum class, which is to be put into its class object (and not into the
* corresponding package). This applies to enum entries, values() and valueOf(String) methods
* corresponding package). This applies to enum entries, values() and valueOf(String) methods
*/
public static boolean shouldBeInEnumClassObject(@NotNull PsiMember member) {
PsiClass psiClass = member.getContainingClass();
@@ -169,7 +139,7 @@ public final class DescriptorResolverUtils {
if (!(member instanceof PsiMethod)) return false;
String signature = PsiFormatUtil.formatMethod((PsiMethod) member,
PsiSubstitutor.EMPTY, SHOW_NAME | SHOW_PARAMETERS, SHOW_TYPE | SHOW_FQ_CLASS_NAMES);
PsiSubstitutor.EMPTY, SHOW_NAME | SHOW_PARAMETERS, SHOW_TYPE | SHOW_FQ_CLASS_NAMES);
return "values()".equals(signature) ||
"valueOf(java.lang.String)".equals(signature);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java
+2 -2
View File
@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -40,7 +39,8 @@ public class PackageClassUtils {
}
public static boolean isPackageClass(@NotNull PsiClass psiClass) {
return JetPackageClassAnnotation.get(psiClass).isDefined();
//TODO: read kotlin info
return psiClass.getName().endsWith("Package");
}
public static boolean isPackageClass(@NotNull FqName fqName) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java
+2 -19
View File
@@ -25,11 +25,8 @@ import com.intellij.psi.impl.PsiSubstitutorImpl;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.JetTypeImpl;
@@ -71,7 +68,7 @@ class PropagationHeuristics {
JetType elementType = type.getArguments().get(0).getType();
if (JetTypeChecker.INSTANCE.isSubtypeOf(elementType, elementTypeInSuper)
&& !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) {
&& !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) {
JetTypeImpl betterTypeInSuper = new JetTypeImpl(
arrayTypeFromSuper.getAnnotations(),
arrayTypeFromSuper.getConstructor(),
@@ -127,21 +124,7 @@ class PropagationHeuristics {
@NotNull
static List<PsiMethod> getSuperMethods(@NotNull PsiMethod method) {
List<PsiMethod> superMethods = Lists.newArrayList();
for (PsiMethod superMethod : new SuperMethodCollector(method).collect()) {
CallableMemberDescriptor.Kind kindFromFlags =
DescriptorKindUtils.flagsToKind(new PsiMethodWrapper(superMethod).getJetMethodAnnotation().kind());
if (kindFromFlags == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
// This is for the case when a Kotlin class inherits a non-abstract method from a trait:
// from Kotlin's point of view it is fake override, from Java's it is normal override.
// We replace this "fake override" method with original method from the trait.
superMethods.addAll(getSuperMethods(superMethod));
}
else {
superMethods.add(superMethod);
}
}
return superMethods;
return new SuperMethodCollector(method).collect();
}
private PropagationHeuristics() {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java
-44
View File
@@ -1,44 +0,0 @@
/*
* 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.kt;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
public class JetClassObjectAnnotation extends PsiAnnotationWithAbiVersion {
private static final JetClassObjectAnnotation NULL_ANNOTATION = new JetClassObjectAnnotation(null);
static {
NULL_ANNOTATION.checkInitialized();
}
private JetClassObjectAnnotation(@Nullable PsiAnnotation psiAnnotation) {
super(psiAnnotation);
}
@NotNull
public static JetClassObjectAnnotation get(@NotNull PsiClass psiClass) {
PsiAnnotation annotation =
JavaAnnotationResolver.findOwnAnnotation(psiClass, JvmStdlibNames.JET_CLASS_OBJECT.getFqName().asString());
return annotation != null ? new JetClassObjectAnnotation(annotation) : NULL_ANNOTATION;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java
-54
View File
@@ -1,54 +0,0 @@
/*
* 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.kt;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiMethod;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
public class JetConstructorAnnotation extends PsiAnnotationWithFlags {
private static final JetConstructorAnnotation NULL_ANNOTATION = new JetConstructorAnnotation(null);
static {
NULL_ANNOTATION.checkInitialized();
}
private JetConstructorAnnotation(@Nullable PsiAnnotation psiAnnotation) {
super(psiAnnotation);
}
@Override
protected void initialize() {
super.initialize();
hidden = getBooleanAttribute(JvmStdlibNames.JET_CONSTRUCTOR_HIDDEN_FIELD, false);
}
private boolean hidden;
/** @deprecated */
public boolean hidden() {
checkInitialized();
return hidden;
}
public static JetConstructorAnnotation get(PsiMethod constructor) {
PsiAnnotation annotation =
JavaAnnotationResolver.findOwnAnnotation(constructor, JvmStdlibNames.JET_CONSTRUCTOR.getFqName().asString());
return annotation != null ? new JetConstructorAnnotation(annotation) : NULL_ANNOTATION;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java
-75
View File
@@ -1,75 +0,0 @@
/*
* 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.kt;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiMethod;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
public class JetMethodAnnotation extends PsiAnnotationWithFlags {
private static final JetMethodAnnotation NULL_ANNOTATION = new JetMethodAnnotation(null);
static {
NULL_ANNOTATION.checkInitialized();
}
private String typeParameters;
private String returnType;
private String propertyType;
private JetMethodAnnotation(@Nullable PsiAnnotation psiAnnotation) {
super(psiAnnotation);
}
@Override
protected void initialize() {
super.initialize();
typeParameters = getStringAttribute(JvmStdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD, "");
returnType = getStringAttribute(JvmStdlibNames.JET_METHOD_RETURN_TYPE_FIELD, "");
propertyType = getStringAttribute(JvmStdlibNames.JET_METHOD_PROPERTY_TYPE_FIELD, "");
}
public int kind() {
return flags() & JvmStdlibNames.FLAG_METHOD_KIND_MASK;
}
@NotNull
public String typeParameters() {
checkInitialized();
return typeParameters;
}
@NotNull
public String returnType() {
checkInitialized();
return returnType;
}
@NotNull
public String propertyType() {
checkInitialized();
return propertyType;
}
public static JetMethodAnnotation get(PsiMethod psiMethod) {
PsiAnnotation annotation =
JavaAnnotationResolver.findOwnAnnotation(psiMethod, JvmStdlibNames.JET_METHOD.getFqName().asString());
return annotation != null ? new JetMethodAnnotation(annotation) : NULL_ANNOTATION;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java
-42
View File
@@ -1,42 +0,0 @@
/*
* 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.kt;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
public class JetPackageClassAnnotation extends PsiAnnotationWithAbiVersion {
private static final JetPackageClassAnnotation NULL_ANNOTATION = new JetPackageClassAnnotation(null);
static {
NULL_ANNOTATION.checkInitialized();
}
private JetPackageClassAnnotation(@Nullable PsiAnnotation psiAnnotation) {
super(psiAnnotation);
}
@NotNull
public static JetPackageClassAnnotation get(PsiClass psiClass) {
PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiClass,
JvmStdlibNames.JET_PACKAGE_CLASS.getFqName().asString());
return annotation != null ? new JetPackageClassAnnotation(annotation) : NULL_ANNOTATION;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java
-46
View File
@@ -1,46 +0,0 @@
/*
* 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.kt;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiParameter;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
public class JetTypeParameterAnnotation extends PsiAnnotationWrapper {
private static final JetTypeParameterAnnotation NULL_ANNOTATION = new JetTypeParameterAnnotation(null);
static {
NULL_ANNOTATION.checkInitialized();
}
private JetTypeParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) {
super(psiAnnotation);
}
@Override
protected void initialize() {
}
@NotNull
public static JetTypeParameterAnnotation get(@NotNull PsiParameter psiParameter) {
PsiAnnotation annotation =
JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_TYPE_PARAMETER.getFqName().asString());
return annotation != null ? new JetTypeParameterAnnotation(annotation) : NULL_ANNOTATION;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java
+1 -7
View File
@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
private static final JetValueParameterAnnotation NULL_ANNOTATION = new JetValueParameterAnnotation(null);
static {
NULL_ANNOTATION.checkInitialized();
}
@@ -32,7 +33,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
private String name;
private String type;
private boolean receiver;
private boolean hasDefaultValue;
private boolean vararg;
private JetValueParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) {
@@ -44,7 +44,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
name = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_NAME_FIELD, "");
type = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, "");
receiver = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_RECEIVER_FIELD, false);
hasDefaultValue = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD, false);
vararg = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_VARARG, false);
}
@@ -64,11 +63,6 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper {
checkInitialized();
return receiver;
}
public boolean hasDefaultValue() {
checkInitialized();
return hasDefaultValue;
}
public boolean vararg() {
checkInitialized();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/PsiAnnotationWithFlags.java
-24
View File
@@ -36,28 +36,4 @@ public abstract class PsiAnnotationWithFlags extends PsiAnnotationWrapper {
checkInitialized();
return flags;
}
public final boolean hasPropertyFlag() {
return (flags() & JvmStdlibNames.FLAG_PROPERTY_BIT) != 0;
}
public final boolean hasForceFinalFlag() {
return (flags() & JvmStdlibNames.FLAG_FORCE_FINAL_BIT) != 0;
}
public final boolean hasForceOpenFlag() {
return (flags() & JvmStdlibNames.FLAG_FORCE_OPEN_BIT) != 0;
}
public final boolean hasInternalFlag() {
return (flags() & JvmStdlibNames.FLAG_INTERNAL_BIT) != 0;
}
public final boolean hasProtectedFlag() {
return (flags() & JvmStdlibNames.FLAG_PROTECTED_BIT) != 0;
}
public final boolean hasPrivateFlag() {
return (flags() & JvmStdlibNames.FLAG_PRIVATE_BIT) != 0;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java
+3 -3
View File
@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java.provider;
import com.intellij.psi.PsiClass;
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.PsiClassFinder;
import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
@@ -47,7 +46,8 @@ public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase
@Override
@NotNull
protected MembersCache buildMembersCache() {
return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers, getDeclarationOrigin() == KOTLIN);
return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers,
getDeclarationOrigin() == KOTLIN);
}
@Override
@@ -64,7 +64,7 @@ public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase
@NotNull
private static DeclarationOrigin determineOrigin(@Nullable PsiClass psiClass) {
return ((psiClass != null) && DescriptorResolverUtils.isKotlinClass(psiClass)) ? KOTLIN : JAVA;
return JAVA;
}
@Override
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java
-58
View File
@@ -1,58 +0,0 @@
/*
* 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.provider;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclarationProviderImpl implements PackagePsiDeclarationProvider {
@NotNull
private final PsiPackage psiPackage;
public KotlinNamespacePsiDeclarationProvider(
@NotNull PsiPackage psiPackage,
@NotNull PsiClass psiClass,
@NotNull PsiClassFinder psiClassFinder
) {
super(psiClass, true, psiClassFinder);
this.psiPackage = psiPackage;
}
@NotNull
@Override
public PsiPackage getPsiPackage() {
return psiPackage;
}
@NotNull
@Override
protected MembersCache buildMembersCache() {
MembersCache cacheWithMembers = super.buildMembersCache();
MembersCache.buildMembersByNameCache(cacheWithMembers, psiClassFinder, null, psiPackage, true, getDeclarationOrigin() == KOTLIN);
return cacheWithMembers;
}
@NotNull
@Override
public DeclarationOrigin getDeclarationOrigin() {
return KOTLIN;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java
+12 -96
View File
@@ -19,16 +19,15 @@ package org.jetbrains.jet.lang.resolve.java.provider;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;
import com.intellij.openapi.util.Ref;
import com.intellij.psi.*;
import com.intellij.psi.util.MethodSignature;
import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
import com.intellij.psi.util.PsiFormatUtil;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
import org.jetbrains.jet.lang.resolve.java.TypeSource;
import org.jetbrains.jet.lang.resolve.java.prop.PropertyNameUtils;
import org.jetbrains.jet.lang.resolve.java.prop.PropertyParseResult;
import org.jetbrains.jet.lang.resolve.java.wrapper.*;
@@ -129,9 +128,6 @@ public final class MembersCache {
private void process() {
for (PsiClass psiClass : psiClasses) {
if (!(psiClass instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses
if (JetClassAnnotation.get(psiClass).kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT) {
processObjectClass(psiClass);
}
if (isSamInterface(psiClass)) {
processSamInterface(psiClass);
}
@@ -139,16 +135,6 @@ public final class MembersCache {
}
}
private void processObjectClass(@NotNull PsiClass psiClass) {
PsiField instanceField = psiClass.findFieldByName(JvmAbi.INSTANCE_FIELD, false);
if (instanceField != null) {
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName()));
TypeSource type = new TypeSource("", instanceField.getType(), instanceField);
namedMembers.addPropertyAccessor(new PropertyPsiDataElement(new PsiFieldWrapper(instanceField), type, null));
}
}
private void processSamInterface(@NotNull PsiClass psiClass) {
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName()));
namedMembers.setSamInterface(psiClass);
@@ -248,9 +234,7 @@ public final class MembersCache {
return false;
}
//process private accessors
if (member.isPrivate()
&& !(member instanceof PsiMethodWrapper && ((PsiMethodWrapper)member).getJetMethodAnnotation().hasPropertyFlag())) {
if (member.isPrivate()) {
return false;
}
@@ -288,90 +272,25 @@ public final class MembersCache {
if (propertyParseResult != null && propertyParseResult.isGetter()) {
processGetter(ownMethod, method, propertyParseResult);
}
else if (propertyParseResult != null && !propertyParseResult.isGetter()) {
else if (propertyParseResult != null) {
processSetter(method, propertyParseResult);
}
if (!method.getJetMethodAnnotation().hasPropertyFlag()) {
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName()));
namedMembers.addMethod(method);
}
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(method.getName()));
namedMembers.addMethod(method);
}
//TODO: manually!!!!
private void processSetter(PsiMethodWrapper method, PropertyParseResult propertyParseResult) {
//TODO
String propertyName = propertyParseResult.getPropertyName();
NamedMembers members = getOrCreateEmpty(Name.identifier(propertyName));
if (method.getJetMethodAnnotation().hasPropertyFlag()) {
if (method.getParameters().size() == 0) {
// TODO: report error properly
throw new IllegalStateException();
}
int i = 0;
TypeSource receiverType = null;
PsiParameterWrapper p1 = method.getParameter(0);
if (p1.getJetValueParameter().receiver()) {
receiverType = new TypeSource(p1.getJetValueParameter().type(), p1.getPsiParameter().getType(), p1.getPsiParameter());
++i;
}
while (i < method.getParameters().size() && method.getParameter(i).getJetTypeParameter().isDefined()) {
++i;
}
if (i + 1 != method.getParameters().size()) {
throw new IllegalStateException();
}
PsiParameterWrapper propertyTypeParameter = method.getParameter(i);
TypeSource propertyType =
new TypeSource(method.getJetMethodAnnotation().propertyType(), propertyTypeParameter.getPsiParameter().getType(),
propertyTypeParameter.getPsiParameter());
members.addPropertyAccessor(new PropertyPsiDataElement(method, false, propertyType, receiverType));
}
getOrCreateEmpty(Name.identifier(propertyName));
}
private void processGetter(PsiMethod ownMethod, PsiMethodWrapper method, PropertyParseResult propertyParseResult) {
//TODO:
String propertyName = propertyParseResult.getPropertyName();
NamedMembers members = getOrCreateEmpty(Name.identifier(propertyName));
// TODO: some java properties too
if (method.getJetMethodAnnotation().hasPropertyFlag()) {
int i = 0;
TypeSource receiverType;
if (i < method.getParameters().size() && method.getParameter(i).getJetValueParameter().receiver()) {
PsiParameterWrapper receiverParameter = method.getParameter(i);
receiverType =
new TypeSource(receiverParameter.getJetValueParameter().type(), receiverParameter.getPsiParameter().getType(),
receiverParameter.getPsiParameter());
++i;
}
else {
receiverType = null;
}
while (i < method.getParameters().size() && method.getParameter(i).getJetTypeParameter().isDefined()) {
// TODO: store is reified
++i;
}
if (i != method.getParameters().size()) {
// TODO: report error properly
throw new IllegalStateException("something is wrong with method " + ownMethod);
}
// TODO: what if returnType == null?
PsiType returnType = method.getReturnType();
assert returnType != null;
TypeSource propertyType = new TypeSource(method.getJetMethodAnnotation().propertyType(), returnType, method.getPsiMethod());
members.addPropertyAccessor(new PropertyPsiDataElement(method, true, propertyType, receiverType));
}
getOrCreateEmpty(Name.identifier(propertyName));
}
private void createEmptyEntry(@NotNull Name identifier) {
@@ -413,9 +332,6 @@ public final class MembersCache {
// Returns null if not SAM interface
@Nullable
public static PsiMethod getSamInterfaceMethod(@NotNull PsiClass psiClass) {
if (DescriptorResolverUtils.isKotlinClass(psiClass)) {
return null;
}
String qualifiedName = psiClass.getQualifiedName();
if (qualifiedName == null || qualifiedName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.asString() + ".")) {
return null;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java
-6
View File
@@ -38,12 +38,6 @@ public final class PsiDeclarationProviderFactory {
return new ClassPsiDeclarationProviderImpl(psiClass, false, psiClassFinder);
}
@NotNull
public KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
@NotNull PsiPackage psiPackage, @NotNull PsiClass psiClass) {
return new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass, psiClassFinder);
}
@NotNull
public PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) {
return new PackagePsiDeclarationProviderImpl(psiPackage, psiClassFinder);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java
-168
View File
@@ -1,168 +0,0 @@
/*
* 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.resolver;
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.ClassKind;
import org.jetbrains.jet.lang.descriptors.Modality;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation;
import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.FqNameBase;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import javax.inject.Inject;
import java.util.Collections;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
public final class JavaClassObjectResolver {
private BindingTrace trace;
private JavaSemanticServices semanticServices;
private JavaSupertypeResolver supertypesResolver;
@Inject
public void setSupertypesResolver(JavaSupertypeResolver supertypesResolver) {
this.supertypesResolver = supertypesResolver;
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
}
@Nullable
public ClassDescriptorFromJvmBytecode createClassObjectDescriptor(
@NotNull ClassDescriptor containing,
@NotNull PsiClass psiClass
) {
DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
if (psiClass.isEnum()) {
return createClassObjectDescriptorForEnum(containing, psiClass);
}
if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
return null;
}
PsiClass classObjectPsiClass = getClassObjectPsiClass(psiClass);
if (classObjectPsiClass == null) {
return null;
}
return createClassObjectFromPsi(containing, classObjectPsiClass);
}
@NotNull
private ClassDescriptorFromJvmBytecode createClassObjectFromPsi(
@NotNull ClassDescriptor containing,
@NotNull PsiClass classObjectPsiClass
) {
String qualifiedName = classObjectPsiClass.getQualifiedName();
assert qualifiedName != null;
FqName fqName = new FqName(qualifiedName);
ClassPsiDeclarationProvider classObjectData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(classObjectPsiClass);
ClassDescriptorFromJvmBytecode classObjectDescriptor
= new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
classObjectDescriptor.setSupertypes(supertypesResolver.getSupertypes(classObjectDescriptor,
new PsiClassWrapper(classObjectPsiClass),
classObjectData,
Collections.<TypeParameterDescriptor>emptyList()));
setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, classObjectData, getClassObjectName(containing.getName()));
return classObjectDescriptor;
}
@NotNull
private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
@NotNull ClassDescriptor containing,
@NotNull PsiClass psiClass
) {
ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
return classObjectDescriptor;
}
@NotNull
private ClassDescriptorFromJvmBytecode createSyntheticClassObject(
@NotNull ClassDescriptor containing,
@NotNull PsiClass psiClass
) {
FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass);
ClassDescriptorFromJvmBytecode classObjectDescriptor =
new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass);
setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().asString()));
return classObjectDescriptor;
}
private void setUpClassObjectDescriptor(
@NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor,
@NotNull ClassDescriptor containing,
@NotNull FqNameBase fqName,
@NotNull ClassPsiDeclarationProvider data,
@NotNull Name classObjectName
) {
classObjectDescriptor.setName(classObjectName);
classObjectDescriptor.setModality(Modality.FINAL);
classObjectDescriptor.setVisibility(containing.getVisibility());
classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
classObjectDescriptor.createTypeConstructor();
JavaClassNonStaticMembersScope classMembersScope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
WritableScopeImpl writableScope =
new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
classObjectDescriptor.setScopeForMemberLookup(writableScope);
classObjectDescriptor.setScopeForConstructorResolve(classMembersScope);
}
@Nullable
private static PsiClass getClassObjectPsiClass(@NotNull PsiClass ownerClass) {
for (PsiClass inner : ownerClass.getInnerClasses()) {
if (JetClassObjectAnnotation.get(inner).isDefined()) {
return inner;
}
}
return null;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
+64 -26
View File
@@ -32,7 +32,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
import org.jetbrains.jet.lang.resolve.java.provider.MembersCache;
import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
@@ -44,16 +43,20 @@ import org.jetbrains.jet.lang.resolve.name.FqNameBase;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValuesMethod;
import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
public final class JavaClassResolver {
@@ -85,7 +88,6 @@ public final class JavaClassResolver {
private JavaAnnotationResolver annotationResolver;
private PsiClassFinder psiClassFinder;
private JavaNamespaceResolver namespaceResolver;
private JavaClassObjectResolver classObjectResolver;
private JavaSupertypeResolver supertypesResolver;
private JavaFunctionResolver functionResolver;
private DeserializedDescriptorResolver kotlinDescriptorResolver;
@@ -108,11 +110,6 @@ public final class JavaClassResolver {
this.signatureResolver = signatureResolver;
}
@Inject
public void setClassObjectResolver(JavaClassObjectResolver classObjectResolver) {
this.classObjectResolver = classObjectResolver;
}
@Inject
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
@@ -258,6 +255,7 @@ public final class JavaClassResolver {
return doCreateClassDescriptor(fqName, psiClass, taskList, containingDeclaration);
}
@NotNull
private ClassDescriptorFromJvmBytecode doCreateClassDescriptor(
@NotNull FqName fqName,
@@ -265,12 +263,7 @@ public final class JavaClassResolver {
@NotNull PostponedTasks taskList,
@NotNull ClassOrNamespaceDescriptor containingDeclaration
) {
JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
if (jetClassAnnotation.isDefined()) {
AbiVersionUtil.checkAbiVersion(psiClass, jetClassAnnotation.getAbiVersion(), trace);
}
ClassKind kind = getClassKind(psiClass, jetClassAnnotation);
ClassKind kind = getClassKind(psiClass);
ClassPsiDeclarationProvider classData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(psiClass);
ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(
containingDeclaration, kind, isInnerClass(psiClass));
@@ -279,12 +272,12 @@ public final class JavaClassResolver {
classDescriptor.setName(Name.identifier(psiClass.getName()));
List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
= signatureResolver.createUninitializedClassTypeParameters(psiClass, classDescriptor);
= JavaSignatureResolver.createUninitializedClassTypeParameters(psiClass, classDescriptor);
classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations));
List<JetType> supertypes = Lists.newArrayList();
classDescriptor.setSupertypes(supertypes);
classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass, jetClassAnnotation));
classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass));
classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
classDescriptor.createTypeConstructor();
JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, semanticServices);
@@ -298,9 +291,9 @@ public final class JavaClassResolver {
List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, new PsiClassWrapper(psiClass), classData, classTypeParameters));
ClassDescriptorFromJvmBytecode classObjectDescriptor = classObjectResolver.createClassObjectDescriptor(classDescriptor, psiClass);
cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor);
if (classObjectDescriptor != null) {
if (psiClass.isEnum()) {
ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass);
cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor);
classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor);
}
@@ -468,20 +461,65 @@ public final class JavaClassResolver {
}
@NotNull
private static ClassKind getClassKind(@NotNull PsiClass psiClass, @NotNull JetClassAnnotation jetClassAnnotation) {
private static ClassKind getClassKind(@NotNull PsiClass psiClass) {
if (psiClass.isInterface()) {
return (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT);
}
if (psiClass.isEnum()) {
return ClassKind.ENUM_CLASS;
}
else {
return jetClassAnnotation.kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT ? ClassKind.OBJECT : ClassKind.CLASS;
}
return ClassKind.CLASS;
}
@Nullable
public ClassDescriptor resolveClass(FqName name) {
return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
}
@NotNull
private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(
@NotNull ClassDescriptor containing,
@NotNull PsiClass psiClass
) {
ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
return classObjectDescriptor;
}
@NotNull
private ClassDescriptorFromJvmBytecode createSyntheticClassObject(
@NotNull ClassDescriptor containing,
@NotNull PsiClass psiClass
) {
ClassDescriptorFromJvmBytecode classObjectDescriptor =
new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
ClassPsiDeclarationProvider data =
semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass);
setUpClassObjectDescriptor(classObjectDescriptor, containing, data, getClassObjectName(containing.getName().asString()));
return classObjectDescriptor;
}
private void setUpClassObjectDescriptor(
@NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor,
@NotNull ClassDescriptor containing,
@NotNull ClassPsiDeclarationProvider data,
@NotNull Name classObjectName
) {
classObjectDescriptor.setName(classObjectName);
classObjectDescriptor.setModality(Modality.FINAL);
classObjectDescriptor.setVisibility(containing.getVisibility());
classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
classObjectDescriptor.createTypeConstructor();
JavaClassNonStaticMembersScope classMembersScope =
new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
WritableScopeImpl writableScope =
new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION,
"Member lookup scope");
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
classObjectDescriptor.setScopeForMemberLookup(writableScope);
classObjectDescriptor.setScopeForConstructorResolve(classMembersScope);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java
+4 -17
View File
@@ -30,7 +30,6 @@ 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.kt.JetConstructorAnnotation;
import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -102,7 +101,8 @@ public final class JavaConstructorResolver {
containingClass,
Collections.<AnnotationDescriptor>emptyList(),
true);
constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), constructorVisibility, isStatic);
constructorDescriptor
.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), constructorVisibility, isStatic);
constructors.add(constructorDescriptor);
trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
}
@@ -175,27 +175,14 @@ public final class JavaConstructorResolver {
) {
PsiMethodWrapper constructor = new PsiMethodWrapper(psiConstructor);
JetConstructorAnnotation constructorAnnotation = constructor.getJetConstructorAnnotation();
//noinspection deprecation
if (constructorAnnotation.hidden()) {
return null;
}
// Do not resolve kotlin constructors without JetConstructorAnnotation
if (DescriptorResolverUtils.isKotlinClass(psiClass) && !constructorAnnotation.isDefined()) {
return null;
}
if (trace.get(BindingContext.CONSTRUCTOR, psiConstructor) != null) {
return trace.get(BindingContext.CONSTRUCTOR, psiConstructor);
}
boolean primary = constructor.getJetConstructorAnnotation().isDefined();
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
classDescriptor,
Collections.<AnnotationDescriptor>emptyList(), // TODO
primary);
false);
String context = "constructor of class " + psiClass.getQualifiedName();
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors(
@@ -219,7 +206,7 @@ public final class JavaConstructorResolver {
constructorDescriptor.initialize(classDescriptor.getTypeConstructor().getParameters(),
valueParameterDescriptors.getDescriptors(),
DescriptorResolverUtils.resolveVisibility(psiConstructor, constructorAnnotation),
DescriptorResolverUtils.resolveVisibility(psiConstructor),
aStatic);
trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
return constructorDescriptor;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java
+32 -42
View File
@@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData;
import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
import org.jetbrains.jet.lang.resolve.java.provider.*;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -115,11 +114,6 @@ public final class JavaFunctionResolver {
return null;
}
// TODO: ugly
if (method.getJetMethodAnnotation().hasPropertyFlag()) {
return null;
}
PsiMethod psiMethod = method.getPsiMethod();
PsiClass containingClass = psiMethod.getContainingClass();
if (declarationOrigin == KOTLIN) {
@@ -139,7 +133,7 @@ public final class JavaFunctionResolver {
ownerDescriptor,
annotationResolver.resolveAnnotations(psiMethod),
Name.identifier(method.getName()),
DescriptorKindUtils.flagsToKind(method.getJetMethodAnnotation().kind())
CallableMemberDescriptor.Kind.DECLARATION
);
String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName();
@@ -159,7 +153,7 @@ public final class JavaFunctionResolver {
List<String> signatureErrors = Lists.newArrayList();
List<FunctionDescriptor> superFunctions;
if (ownerDescriptor instanceof ClassDescriptor && !method.getJetMethodAnnotation().isDefined()) { // don't propagate for Kotlin functions
if (ownerDescriptor instanceof ClassDescriptor) {
SignaturesPropagationData signaturesPropagationData = new SignaturesPropagationData(
(ClassDescriptor) ownerDescriptor, returnType, valueParameterDescriptors, methodTypeParameters, method, trace);
superFunctions = signaturesPropagationData.getSuperFunctions();
@@ -192,8 +186,8 @@ public final class JavaFunctionResolver {
methodTypeParameters,
valueParameterDescriptors.getDescriptors(),
returnType,
DescriptorResolverUtils.resolveModality(method, method.isFinal()),
DescriptorResolverUtils.resolveVisibility(psiMethod, method.getJetMethodAnnotation()),
Modality.convertFromFlags(method.isAbstract(), !method.isFinal()),
DescriptorResolverUtils.resolveVisibility(psiMethod),
/*isInline = */ false
);
@@ -210,8 +204,8 @@ public final class JavaFunctionResolver {
}
if (!RawTypesCheck.hasRawTypesInHierarchicalSignature(psiMethod)
&& JavaMethodSignatureUtil.isMethodReturnTypeCompatible(psiMethod)
&& !containsErrorType(superFunctions, functionDescriptorImpl)) {
&& JavaMethodSignatureUtil.isMethodReturnTypeCompatible(psiMethod)
&& !containsErrorType(superFunctions, functionDescriptorImpl)) {
if (signatureErrors.isEmpty()) {
checkFunctionsOverrideCorrectly(method, superFunctions, functionDescriptorImpl);
}
@@ -276,13 +270,11 @@ public final class JavaFunctionResolver {
Set<SimpleFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
for (PsiMethodWrapper method : namedMembers.getMethods()) {
SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true);
SimpleFunctionDescriptor function =
resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true);
if (function != null) {
functionsFromCurrent.add(function);
if (!DescriptorResolverUtils.isKotlinClass(psiClass)) {
ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function));
}
ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function));
}
}
@@ -296,20 +288,20 @@ public final class JavaFunctionResolver {
ClassDescriptor classDescriptor = (ClassDescriptor) owner;
OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor,
new OverrideResolver.DescriptorSink() {
@Override
public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
fakeOverrides.add((FunctionDescriptor) fakeOverride);
}
new OverrideResolver.DescriptorSink() {
@Override
public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
fakeOverrides.add((FunctionDescriptor) fakeOverride);
}
@Override
public void conflict(
@NotNull CallableMemberDescriptor fromSuper,
@NotNull CallableMemberDescriptor fromCurrent
) {
// nop
}
});
@Override
public void conflict(
@NotNull CallableMemberDescriptor fromSuper,
@NotNull CallableMemberDescriptor fromCurrent
) {
// nop
}
});
}
OverrideResolver.resolveUnknownVisibilities(fakeOverrides, trace);
@@ -426,18 +418,12 @@ public final class JavaFunctionResolver {
@NotNull TypeVariableResolver typeVariableResolver
) {
String returnTypeFromAnnotation = method.getJetMethodAnnotation().returnType();
TypeUsage typeUsage = JavaTypeTransformer
.adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT);
JetType transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver);
JetType transformedType;
if (returnTypeFromAnnotation.length() > 0) {
transformedType = typeTransformer.transformToType(returnTypeFromAnnotation, typeVariableResolver);
}
else {
TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(method.getPsiMethod(), TypeUsage.MEMBER_SIGNATURE_COVARIANT);
transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver);
}
if (JavaAnnotationResolver.findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
if (JavaAnnotationResolver
.findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
null) {
return TypeUtils.makeNullableAsSpecified(transformedType, false);
}
@@ -473,7 +459,11 @@ public final class JavaFunctionResolver {
return false;
}
private static SimpleFunctionDescriptor recordSamConstructor(ClassDescriptorFromJvmBytecode klass, SimpleFunctionDescriptor constructorFunction, BindingTrace trace) {
private static SimpleFunctionDescriptor recordSamConstructor(
ClassDescriptorFromJvmBytecode klass,
SimpleFunctionDescriptor constructorFunction,
BindingTrace trace
) {
trace.record(JavaBindingContext.SAM_CONSTRUCTOR_TO_INTERFACE, constructorFunction, klass);
trace.record(BindingContext.SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, constructorFunction, klass);
return constructorFunction;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java
-9
View File
@@ -20,8 +20,6 @@ import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassObjectAnnotation;
import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -56,19 +54,12 @@ public final class JavaInnerClassResolver {
PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
for (PsiClass innerPsiClass : innerPsiClasses) {
if (shouldBeIgnored(innerPsiClass)) {
continue;
}
ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
result.add(classDescriptor);
}
return result;
}
private static boolean shouldBeIgnored(PsiClass innerPsiClass) {
return JetClassObjectAnnotation.get(innerPsiClass).isDefined();
}
@NotNull
private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {
String name = innerPsiClass.getQualifiedName();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java
+1 -2
View File
@@ -37,7 +37,6 @@ import org.jetbrains.jet.lang.resolve.java.provider.MembersCache;
import org.jetbrains.jet.lang.resolve.java.scope.JavaBaseScope;
import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -201,7 +200,7 @@ public final class JavaNamespaceResolver {
}
private static boolean isOldKotlinPackageClass(@NotNull PsiClass psiClass) {
return new PsiClassWrapper(psiClass).getJetPackageClass().isDefined();
return hasAnnotation(psiClass, JvmStdlibNames.JET_PACKAGE_CLASS.getFqName());
}
private static boolean hasKotlinPackageAnnotation(@NotNull PsiClass psiClass) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java
+13 -19
View File
@@ -30,8 +30,6 @@ import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData;
import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation;
import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
import org.jetbrains.jet.lang.resolve.java.wrapper.*;
@@ -45,6 +43,7 @@ import java.util.*;
import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
//TODO: getters and setter are not working
public final class JavaPropertyResolver {
private JavaSemanticServices semanticServices;
@@ -174,17 +173,16 @@ public final class JavaPropertyResolver {
PropertyPsiDataElement characteristicMember = psiData.getCharacteristicMember();
Visibility visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi(), null);
Visibility visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi());
CallableMemberDescriptor.Kind kind = CallableMemberDescriptor.Kind.DECLARATION;
PropertyPsiDataElement getter = psiData.getGetter();
if (getter != null) {
JetMethodAnnotation methodAnnotation = ((PsiMethodWrapper) getter.getMember()).getJetMethodAnnotation();
visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi(), methodAnnotation);
kind = DescriptorKindUtils.flagsToKind(methodAnnotation.kind());
visibility = DescriptorResolverUtils.resolveVisibility(psiData.getCharacteristicPsi());
}
PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind);
PropertyDescriptorImpl propertyDescriptor =
createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind);
PropertyGetterDescriptorImpl getterDescriptor = resolveGetter(visibility, kind, getter, propertyDescriptor);
PropertySetterDescriptorImpl setterDescriptor = resolveSetter(psiData, kind, propertyDescriptor);
@@ -209,9 +207,7 @@ public final class JavaPropertyResolver {
);
initializeSetterAndGetter(propertyDescriptor, getterDescriptor, setterDescriptor, propertyType, psiData);
if (kind == CallableMemberDescriptor.Kind.DECLARATION) {
trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor);
}
trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor);
if (scopeData.getDeclarationOrigin() == JAVA) {
trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor);
@@ -277,8 +273,8 @@ public final class JavaPropertyResolver {
return new PropertyDescriptorImpl(
owner,
annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()),
DescriptorResolverUtils.resolveModality(psiData.getCharacteristicMember().getMember(),
isFinal || psiData.isPropertyForNamedObject()),
Modality.convertFromFlags(psiData.getCharacteristicMember().getMember().isAbstract(),
!(isFinal || psiData.isPropertyForNamedObject())),
visibility,
isVar,
propertyName,
@@ -310,6 +306,7 @@ public final class JavaPropertyResolver {
return propertyType;
}
//TODO: doesn't work
private static void initializeSetterAndGetter(
@NotNull PropertyDescriptor propertyDescriptor,
@Nullable PropertyGetterDescriptorImpl getterDescriptor,
@@ -325,13 +322,11 @@ public final class JavaPropertyResolver {
assert setter != null;
List<PsiParameterWrapper> parameters = ((PsiMethodWrapper) setter.getMember()).getParameters();
assert parameters.size() != 0;
int valueIndex = parameters.size() - 1;
PsiParameterWrapper valueParameter = parameters.get(valueIndex);
setterDescriptor.initialize(new ValueParameterDescriptorImpl(
setterDescriptor,
0,
Collections.<AnnotationDescriptor>emptyList(),
Name.identifierNoValidate(valueParameter.getJetValueParameter().name()),
Name.identifierNoValidate(""),
propertyDescriptor.getType(),
false,
null));
@@ -368,12 +363,11 @@ public final class JavaPropertyResolver {
if (setter == null) {
return null;
}
Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(setter.getMember().getPsiMember(), null);
Visibility setterVisibility = DescriptorResolverUtils.resolveVisibility(setter.getMember().getPsiMember());
if (setter.getMember() instanceof PsiMethodWrapper) {
setterVisibility = DescriptorResolverUtils.resolveVisibility(
setter.getMember().getPsiMember(),
((PsiMethodWrapper) setter.getMember())
.getJetMethodAnnotation());
setter.getMember().getPsiMember()
);
}
return new PropertySetterDescriptorImpl(
propertyDescriptor,
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
+70 -56
View File
@@ -21,12 +21,14 @@ import com.intellij.psi.*;
import jet.typeinfo.TypeInfoVariance;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.JetType;
@@ -72,7 +74,10 @@ public final class JavaSignatureResolver {
@Nullable
private final List<JetType> upperBoundsForKotlin;
private TypeParameterDescriptorInitialization(@NotNull TypeParameterDescriptorImpl descriptor, @NotNull PsiTypeParameter psiTypeParameter) {
private TypeParameterDescriptorInitialization(
@NotNull TypeParameterDescriptorImpl descriptor,
@NotNull PsiTypeParameter psiTypeParameter
) {
this.origin = TypeParameterDescriptorOrigin.JAVA;
this.descriptor = descriptor;
this.psiTypeParameter = psiTypeParameter;
@@ -96,7 +101,6 @@ public final class JavaSignatureResolver {
}
@NotNull
private static PsiTypeParameter getPsiTypeParameterByName(PsiTypeParameterListOwner clazz, String name) {
for (PsiTypeParameter typeParameter : clazz.getTypeParameters()) {
@@ -108,7 +112,6 @@ public final class JavaSignatureResolver {
}
private abstract class JetSignatureTypeParameterVisitor extends JetSignatureExceptionsAdapter {
@NotNull
@@ -124,8 +127,8 @@ public final class JavaSignatureResolver {
@NotNull PsiTypeParameterListOwner psiOwner,
@NotNull String name,
@NotNull TypeVariableResolver typeVariableResolver,
@NotNull TypeParameterDescriptorImpl typeParameterDescriptor)
{
@NotNull TypeParameterDescriptorImpl typeParameterDescriptor
) {
if (name.isEmpty()) {
throw new IllegalStateException();
}
@@ -164,7 +167,8 @@ public final class JavaSignatureResolver {
@Override
public void visitFormalTypeParameterEnd() {
PsiTypeParameter psiTypeParameter = getPsiTypeParameterByName(psiOwner, name);
TypeParameterDescriptorInitialization typeParameterDescriptorInitialization = new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter, upperBounds);
TypeParameterDescriptorInitialization typeParameterDescriptorInitialization =
new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter, upperBounds);
done(typeParameterDescriptorInitialization);
}
@@ -182,7 +186,11 @@ public final class JavaSignatureResolver {
private final TypeVariableResolver typeVariableResolver;
private JetSignatureTypeParametersVisitor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameterListOwner psiOwner, @NotNull String context) {
private JetSignatureTypeParametersVisitor(
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull PsiTypeParameterListOwner psiOwner,
@NotNull String context
) {
this.containingDeclaration = containingDeclaration;
this.psiOwner = psiOwner;
@@ -219,37 +227,41 @@ public final class JavaSignatureResolver {
}
}
/**
/**
* @see #resolveMethodTypeParametersFromJetSignature(String, PsiMethod, DeclarationDescriptor)
*/
private List<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(String jetSignature,
final PsiClass clazz, final ClassDescriptor classDescriptor) {
private List<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(
String jetSignature,
final PsiClass clazz, final ClassDescriptor classDescriptor
) {
String context = "class " + clazz.getQualifiedName();
JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) {
@Override
public JetSignatureVisitor visitSuperclass() {
// TODO
return new JetSignatureAdapter();
}
JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor =
new JetSignatureTypeParametersVisitor(classDescriptor, clazz, context) {
@Override
public JetSignatureVisitor visitSuperclass() {
// TODO
return new JetSignatureAdapter();
}
@Override
public JetSignatureVisitor visitInterface() {
// TODO
return new JetSignatureAdapter();
}
};
@Override
public JetSignatureVisitor visitInterface() {
// TODO
return new JetSignatureAdapter();
}
};
new JetSignatureReader(jetSignature).accept(jetSignatureTypeParametersVisitor);
return jetSignatureTypeParametersVisitor.r;
}
private static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull PsiTypeParameter[] typeParameters
) {
private static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull PsiTypeParameter[] typeParameters
) {
List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
for (PsiTypeParameter typeParameter : typeParameters) {
TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(containingDeclaration, typeParameter);
TypeParameterDescriptorInitialization typeParameterDescriptor =
makeUninitializedTypeParameter(containingDeclaration, typeParameter);
result.add(typeParameterDescriptor);
}
return result;
@@ -271,12 +283,15 @@ public final class JavaSignatureResolver {
return new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter);
}
private void initializeTypeParameter(TypeParameterDescriptorInitialization typeParameter, TypeVariableResolver typeVariableByPsiResolver) {
private void initializeTypeParameter(
TypeParameterDescriptorInitialization typeParameter,
TypeVariableResolver typeVariableByPsiResolver
) {
TypeParameterDescriptorImpl typeParameterDescriptor = typeParameter.descriptor;
if (typeParameter.origin == TypeParameterDescriptorOrigin.KOTLIN) {
List<JetType> upperBoundsForKotlin = typeParameter.upperBoundsForKotlin;
assert upperBoundsForKotlin != null;
if (upperBoundsForKotlin.size() == 0){
if (upperBoundsForKotlin.size() == 0) {
typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
}
else {
@@ -289,15 +304,19 @@ public final class JavaSignatureResolver {
}
else {
PsiClassType[] referencedTypes = typeParameter.psiTypeParameter.getExtendsList().getReferencedTypes();
if (referencedTypes.length == 0){
if (referencedTypes.length == 0) {
typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
}
else if (referencedTypes.length == 1) {
typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer()
.transformToType(referencedTypes[0], TypeUsage.UPPER_BOUND,
typeVariableByPsiResolver));
}
else {
for (PsiClassType referencedType : referencedTypes) {
typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedType, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer()
.transformToType(referencedType, TypeUsage.UPPER_BOUND,
typeVariableByPsiResolver));
}
}
}
@@ -319,22 +338,22 @@ public final class JavaSignatureResolver {
for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
prevTypeParameters.add(psiTypeParameter.descriptor);
initializeTypeParameter(psiTypeParameter,
TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context));
TypeVariableResolvers
.typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context));
}
}
public List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(
@NotNull
public static List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(
PsiClass psiClass, ClassDescriptor classDescriptor
) {
JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
if (jetClassAnnotation.signature().length() > 0) {
return resolveClassTypeParametersFromJetSignature(
jetClassAnnotation.signature(), psiClass, classDescriptor);
List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
for (PsiTypeParameter typeParameter : psiClass.getTypeParameters()) {
TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(classDescriptor, typeParameter);
result.add(typeParameterDescriptor);
}
return makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters());
return result;
}
@@ -343,15 +362,9 @@ public final class JavaSignatureResolver {
@NotNull DeclarationDescriptor functionDescriptor
) {
List<TypeParameterDescriptorInitialization> typeParametersIntialization;
PsiMethod psiMethod = method.getPsiMethod();
if (method.getJetMethodAnnotation().typeParameters().length() > 0) {
typeParametersIntialization = resolveMethodTypeParametersFromJetSignature(
method.getJetMethodAnnotation().typeParameters(), psiMethod, functionDescriptor);
}
else {
typeParametersIntialization = makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters());
}
List<TypeParameterDescriptorInitialization> typeParametersIntialization =
makeUninitializedTypeParameters(functionDescriptor, psiMethod.getTypeParameters());
PsiClass psiMethodContainingClass = psiMethod.getContainingClass();
assert psiMethodContainingClass != null;
@@ -370,15 +383,16 @@ public final class JavaSignatureResolver {
/**
* @see #resolveClassTypeParametersFromJetSignature(String, PsiClass, ClassDescriptor)
*/
private List<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(String jetSignature,
PsiMethod method, DeclarationDescriptor functionDescriptor)
{
private List<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(
String jetSignature,
PsiMethod method, DeclarationDescriptor functionDescriptor
) {
PsiClass methodContainingClass = method.getContainingClass();
assert methodContainingClass != null;
String context = "method " + method.getName() + " in class " + methodContainingClass.getQualifiedName();
JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor = new JetSignatureTypeParametersVisitor(functionDescriptor, method, context);
JetSignatureTypeParametersVisitor jetSignatureTypeParametersVisitor =
new JetSignatureTypeParametersVisitor(functionDescriptor, method, context);
new JetSignatureReader(jetSignature).acceptFormalTypeParametersOnly(jetSignatureTypeParametersVisitor);
return jetSignatureTypeParametersVisitor.r;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java
+5 -58
View File
@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiClassType;
import jet.typeinfo.TypeInfoVariance;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -33,10 +32,6 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.rt.signature.JetSignatureAdapter;
import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter;
import org.jetbrains.jet.rt.signature.JetSignatureReader;
import org.jetbrains.jet.rt.signature.JetSignatureVisitor;
import javax.inject.Inject;
import java.util.ArrayList;
@@ -48,7 +43,6 @@ import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOT
public final class JavaSupertypeResolver {
private BindingTrace trace;
private JavaSemanticServices semanticServices;
private JavaTypeTransformer typeTransformer;
private JavaClassResolver classResolver;
@@ -57,11 +51,6 @@ public final class JavaSupertypeResolver {
this.trace = trace;
}
@Inject
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
}
@Inject
public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
this.typeTransformer = typeTransformer;
@@ -83,15 +72,10 @@ public final class JavaSupertypeResolver {
String context = "class " + psiClass.getQualifiedName();
if (psiClass.getJetClass().signature().length() > 0) {
readSuperTypes(psiClass, typeParameters, classDescriptor, result, context);
}
else {
TypeVariableResolver typeVariableResolverForSupertypes =
TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes);
transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes);
}
TypeVariableResolver typeVariableResolverForSupertypes =
TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes);
transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes);
reportIncompleteHierarchyForErrorTypes(classDescriptor, result);
@@ -101,43 +85,6 @@ public final class JavaSupertypeResolver {
return result;
}
private void readSuperTypes(
PsiClassWrapper psiClass,
List<TypeParameterDescriptor> typeParameters,
ClassDescriptor classDescriptor,
final List<JetType> result,
String context
) {
final TypeVariableResolver typeVariableResolver =
TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context);
new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() {
@Override
public JetSignatureVisitor visitFormalTypeParameter(String name, TypeInfoVariance variance, boolean reified) {
// TODO: collect
return new JetSignatureAdapter();
}
@Override
public JetSignatureVisitor visitSuperclass() {
return new JetTypeJetSignatureReader(semanticServices, KotlinBuiltIns.getInstance(),
typeVariableResolver) {
@Override
protected void done(@NotNull JetType jetType) {
if (!jetType.equals(KotlinBuiltIns.getInstance().getAnyType())) {
result.add(jetType);
}
}
};
}
@Override
public JetSignatureVisitor visitInterface() {
return visitSuperclass();
}
});
}
private void addBaseClass(
@NotNull PsiClassWrapper psiClass,
@NotNull ClassPsiDeclarationProvider classData,
@@ -158,7 +105,7 @@ public final class JavaSupertypeResolver {
else {
//TODO: hack here
result.add(KotlinBuiltIns.getInstance().getAnyType());
// throw new IllegalStateException("Could not resolve java.lang.Object");
// throw new IllegalStateException("Could not resolve java.lang.Object");
}
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java
+20 -46
View File
@@ -22,8 +22,8 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -49,34 +49,17 @@ public final class JavaValueParameterResolver {
PsiParameterWrapper parameter, TypeVariableResolver typeVariableResolver
) {
if (parameter.getJetTypeParameter().isDefined()) {
return JvmMethodParameterMeaning.typeInfo();
}
PsiType psiType = parameter.getPsiParameter().getType();
// TODO: must be very slow, make it lazy?
Name name = Name.identifier(getParameterName(i, parameter));
if (parameter.getJetValueParameter().name().length() > 0) {
name = Name.identifier(parameter.getJetValueParameter().name());
}
String typeFromAnnotation = parameter.getJetValueParameter().type();
boolean receiver = parameter.getJetValueParameter().receiver();
boolean hasDefaultValue = parameter.getJetValueParameter().hasDefaultValue();
JetType outType;
if (typeFromAnnotation.length() > 0) {
outType = getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver);
}
else {
TypeUsage typeUsage = JavaTypeTransformer.adjustTypeUsageWithMutabilityAnnotations(parameter.getPsiParameter(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT);
outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver);
}
TypeUsage typeUsage = JavaTypeTransformer
.adjustTypeUsageWithMutabilityAnnotations(parameter.getPsiParameter(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT);
JetType outType = getTypeTransformer().transformToType(psiType, typeUsage, typeVariableResolver);
JetType varargElementType;
if (psiType instanceof PsiEllipsisType || parameter.getJetValueParameter().vararg()) {
if (psiType instanceof PsiEllipsisType) {
varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(TypeUtils.makeNotNullable(outType));
outType = TypeUtils.makeNotNullable(outType);
}
@@ -84,29 +67,24 @@ public final class JavaValueParameterResolver {
varargElementType = null;
}
if (receiver) {
return JvmMethodParameterMeaning.receiver(outType);
JetType transformedType;
if (JavaAnnotationResolver
.findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
null) {
transformedType = TypeUtils.makeNullableAsSpecified(outType, false);
}
else {
JetType transformedType;
if (JavaAnnotationResolver.findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) !=
null) {
transformedType = TypeUtils.makeNullableAsSpecified(outType, false);
}
else {
transformedType = outType;
}
return JvmMethodParameterMeaning.regular(new ValueParameterDescriptorImpl(
containingDeclaration,
i,
Collections.<AnnotationDescriptor>emptyList(), // TODO
name,
transformedType,
hasDefaultValue,
varargElementType
));
transformedType = outType;
}
return JvmMethodParameterMeaning.regular(new ValueParameterDescriptorImpl(
containingDeclaration,
i,
Collections.<AnnotationDescriptor>emptyList(), // TODO
name,
transformedType,
false,
varargElementType
));
}
@NotNull
@@ -182,9 +160,5 @@ public final class JavaValueParameterResolver {
public static JvmMethodParameterMeaning regular(@NotNull ValueParameterDescriptor valueParameterDescriptor) {
return new JvmMethodParameterMeaning(JvmMethodParameterKind.REGULAR, null, valueParameterDescriptor);
}
public static JvmMethodParameterMeaning typeInfo() {
return new JvmMethodParameterMeaning(JvmMethodParameterKind.TYPE_INFO, null, null);
}
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaScopeForKotlinNamespace.java
-56
View File
@@ -1,56 +0,0 @@
/*
* 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.scope;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
import org.jetbrains.jet.lang.resolve.java.provider.KotlinNamespacePsiDeclarationProvider;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import java.util.Collection;
import java.util.Set;
public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
@NotNull
private final KotlinNamespacePsiDeclarationProvider declarationProvider;
public JavaScopeForKotlinNamespace(
@NotNull NamespaceDescriptor descriptor,
@NotNull KotlinNamespacePsiDeclarationProvider declarationProvider,
@NotNull FqName packageFQN,
@NotNull JavaSemanticServices semanticServices
) {
super(descriptor, declarationProvider, packageFQN, semanticServices);
this.declarationProvider = declarationProvider;
}
@NotNull
@Override
protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
}
@NotNull
@Override
protected Collection<ClassDescriptor> computeInnerClasses() {
return getResolver().resolveInnerClasses(declarationProvider);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PropertyPsiDataElement.java
-13
View File
@@ -35,19 +35,6 @@ public final class PropertyPsiDataElement {
private final TypeSource type;
@Nullable
private final TypeSource receiverType;
public PropertyPsiDataElement(
@NotNull PsiMethodWrapper method,
boolean getter,
@NotNull TypeSource type,
@Nullable TypeSource receiverType
) {
this.member = method;
this.type = type;
this.receiverType = receiverType;
this.getter = getter;
}
public PropertyPsiDataElement(@NotNull PsiFieldWrapper field, @NotNull TypeSource type, @Nullable TypeSource receiverType) {
this.member = field;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java
-21
View File
@@ -18,8 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.wrapper;
import com.intellij.psi.PsiClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
public class PsiClassWrapper {
@@ -38,23 +36,4 @@ public class PsiClassWrapper {
public PsiClass getPsiClass() {
return psiClass;
}
private JetClassAnnotation jetClass;
private JetPackageClassAnnotation jetPackageClass;
@NotNull
public JetClassAnnotation getJetClass() {
if (jetClass == null) {
jetClass = JetClassAnnotation.get(psiClass);
}
return jetClass;
}
@NotNull
public JetPackageClassAnnotation getJetPackageClass() {
if (jetPackageClass == null) {
jetPackageClass = JetPackageClassAnnotation.get(psiClass);
}
return jetPackageClass;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiMethodWrapper.java
+2 -26
View File
@@ -22,8 +22,6 @@ import com.intellij.psi.PsiParameter;
import com.intellij.psi.PsiType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.java.kt.JetConstructorAnnotation;
import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation;
import java.util.ArrayList;
import java.util.List;
@@ -33,8 +31,9 @@ public class PsiMethodWrapper extends PsiMemberWrapper {
public PsiMethodWrapper(@NotNull PsiMethod psiMethod) {
super(psiMethod);
}
private List<PsiParameterWrapper> parameters;
@NotNull
public List<PsiParameterWrapper> getParameters() {
if (parameters == null) {
@@ -47,29 +46,6 @@ public class PsiMethodWrapper extends PsiMemberWrapper {
return parameters;
}
@NotNull
public PsiParameterWrapper getParameter(int i) {
return getParameters().get(i);
}
private JetMethodAnnotation jetMethodAnnotation;
@NotNull
public JetMethodAnnotation getJetMethodAnnotation() {
if (jetMethodAnnotation == null) {
jetMethodAnnotation = JetMethodAnnotation.get(getPsiMethod());
}
return jetMethodAnnotation;
}
private JetConstructorAnnotation jetConstructorAnnotation;
@NotNull
public JetConstructorAnnotation getJetConstructorAnnotation() {
if (jetConstructorAnnotation == null) {
jetConstructorAnnotation = JetConstructorAnnotation.get(getPsiMethod());
}
return jetConstructorAnnotation;
}
@Override
public boolean isAbstract() {
return psiMember.hasModifierProperty(PsiModifier.ABSTRACT);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiParameterWrapper.java
-20
View File
@@ -18,36 +18,16 @@ package org.jetbrains.jet.lang.resolve.java.wrapper;
import com.intellij.psi.PsiParameter;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.java.kt.JetTypeParameterAnnotation;
import org.jetbrains.jet.lang.resolve.java.kt.JetValueParameterAnnotation;
public class PsiParameterWrapper {
private final PsiParameter psiParameter;
public PsiParameterWrapper(@NotNull PsiParameter psiParameter) {
this.psiParameter = psiParameter;
this.jetValueParameter = JetValueParameterAnnotation.get(psiParameter);
this.jetTypeParameter = JetTypeParameterAnnotation.get(psiParameter);
}
@NotNull
private final JetValueParameterAnnotation jetValueParameter;
@NotNull
private final JetTypeParameterAnnotation jetTypeParameter;
@NotNull
public PsiParameter getPsiParameter() {
return psiParameter;
}
@NotNull
public JetValueParameterAnnotation getJetValueParameter() {
return jetValueParameter;
}
@NotNull
public JetTypeParameterAnnotation getJetTypeParameter() {
return jetTypeParameter;
}
}