diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index 0322bf8e336..0d7a8ca2e63 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -17,8 +17,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Lists; -import com.intellij.psi.PsiArrayType; -import com.intellij.psi.PsiType; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -34,8 +32,10 @@ import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; +import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; +import org.jetbrains.jet.lang.resolve.java.structure.JavaType; import org.jetbrains.jet.lang.types.JetType; import javax.inject.Inject; @@ -147,14 +147,14 @@ public final class JavaConstructorResolver { JavaMethod method = iterator.next(); assert method.getValueParameters().isEmpty() : "Annotation method can't have parameters: " + method; - PsiType returnType = method.getPsi().getReturnType(); + JavaType returnType = method.getReturnType(); assert returnType != null : "Annotation method has no return type: " + method; // We take the following heuristic convention: // if the last method of the @interface is an array, we convert it into a vararg JetType varargElementType = null; - if (!iterator.hasNext() && returnType instanceof PsiArrayType) { - PsiType componentType = ((PsiArrayType) returnType).getComponentType(); + if (!iterator.hasNext() && returnType instanceof JavaArrayType) { + JavaType componentType = ((JavaArrayType) returnType).getComponentType(); varargElementType = typeTransformer.transformToType(componentType, typeVariableResolver); } @@ -201,7 +201,7 @@ public final class JavaConstructorResolver { List typeParameters = classDescriptor.getTypeConstructor().getParameters(); JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors( - constructorDescriptor, constructor.getValueParameters(), + constructorDescriptor, constructor, new TypeVariableResolver(typeParameters, classDescriptor, "constructor of class " + javaClass.getFqName()) ); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 3f39f1ae894..8d0c66fea28 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -20,7 +20,6 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.diagnostic.Logger; import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiType; import com.intellij.psi.util.PsiFormatUtil; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; @@ -36,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagation import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; +import org.jetbrains.jet.lang.resolve.java.structure.JavaType; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; @@ -103,13 +103,14 @@ public final class JavaFunctionResolver { return null; } - PsiMethod psiMethod = method.getPsi(); - - PsiType returnPsiType = psiMethod.getReturnType(); - if (returnPsiType == null) { + JavaType returnJavaType = method.getReturnType(); + if (returnJavaType == null) { + // This means that the method is a constructor return null; } + PsiMethod psiMethod = method.getPsi(); + SimpleFunctionDescriptor alreadyResolved = trace.get(BindingContext.FUNCTION, psiMethod); if (alreadyResolved != null) { return alreadyResolved; @@ -128,8 +129,8 @@ public final class JavaFunctionResolver { methodTypeParameters, functionDescriptorImpl, "method " + method.getName() + " in class " + method.getContainingClass()); JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = parameterResolver - .resolveParameterDescriptors(functionDescriptorImpl, method.getValueParameters(), methodTypeVariableResolver); - JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver); + .resolveParameterDescriptors(functionDescriptorImpl, method, methodTypeVariableResolver); + JetType returnType = makeReturnType(returnJavaType, method, methodTypeVariableResolver); List signatureErrors = Lists.newArrayList(); @@ -362,7 +363,7 @@ public final class JavaFunctionResolver { @NotNull private JetType makeReturnType( - @NotNull PsiType returnType, + @NotNull JavaType returnType, @NotNull JavaMethod method, @NotNull TypeVariableResolver typeVariableResolver ) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 36e0705ec00..9a5d1c464e5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -27,7 +27,10 @@ import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorForObjectImpl; import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl; 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.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.JavaBindingContext; +import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; +import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.java.structure.JavaField; @@ -226,7 +229,7 @@ public final class JavaPropertyResolver { @NotNull private JetType getPropertyType(@NotNull JavaField field, @NotNull TypeVariableResolver typeVariableResolver) { - JetType propertyType = typeTransformer.transformToType(field.getPsi().getType(), typeVariableResolver); + JetType propertyType = typeTransformer.transformToType(field.getType(), typeVariableResolver); boolean hasNotNullAnnotation = JavaAnnotationResolver.findAnnotationWithExternal( field.getPsi(), diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java index 054f8391f38..2c52818f70c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Lists; -import com.intellij.psi.PsiClassType; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; @@ -106,8 +105,7 @@ public final class JavaSignatureResolver { } else { for (JavaClassType upperBound : upperBounds) { - PsiClassType psiClassType = upperBound.getPsi(); - JetType transformedType = typeTransformer.transformToType(psiClassType, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver); + JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver); typeParameterDescriptor.addUpperBound(transformedType); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java index a19fb7589b1..0a5b9c0fd66 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java @@ -125,7 +125,7 @@ public final class JavaSupertypeResolver { } } - JetType transformed = typeTransformer.transformToType(type.getPsi(), TypeUsage.SUPERTYPE, typeVariableResolver); + JetType transformed = typeTransformer.transformToType(type, TypeUsage.SUPERTYPE, typeVariableResolver); if (!ErrorUtils.isErrorType(transformed)) { result.add(TypeUtils.makeNotNullable(transformed)); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java index 4c43f66e00e..9e02df33b2d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; import org.jetbrains.jet.lang.resolve.java.TypeUsage; import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.java.structure.JavaType; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; @@ -75,25 +76,25 @@ public class JavaTypeTransformer { PsiType bound = wildcardType.getBound(); assert bound != null; - return new TypeProjection(variance, transformToType(bound, UPPER_BOUND, typeVariableByPsiResolver)); + return new TypeProjection(variance, transformToType(JavaType.create(bound), UPPER_BOUND, typeVariableByPsiResolver)); } @Override public TypeProjection visitType(PsiType type) { - return new TypeProjection(transformToType(type, howThisTypeIsUsed, typeVariableByPsiResolver)); + return new TypeProjection(transformToType(JavaType.create(type), howThisTypeIsUsed, typeVariableByPsiResolver)); } }); } @NotNull - public JetType transformToType(@NotNull PsiType javaType, @NotNull TypeVariableResolver typeVariableResolver) { + public JetType transformToType(@NotNull JavaType javaType, @NotNull TypeVariableResolver typeVariableResolver) { return transformToType(javaType, TypeUsage.MEMBER_SIGNATURE_INVARIANT, typeVariableResolver); } @NotNull - public JetType transformToType(@NotNull PsiType javaType, @NotNull final TypeUsage howThisTypeIsUsed, + public JetType transformToType(@NotNull JavaType javaType, @NotNull final TypeUsage howThisTypeIsUsed, @NotNull final TypeVariableResolver typeVariableResolver) { - return javaType.accept(new PsiTypeVisitor() { + return javaType.getPsi().accept(new PsiTypeVisitor() { @Override public JetType visitClassType(PsiClassType classType) { PsiClass psiClass = classType.resolve(); @@ -110,7 +111,7 @@ public class JavaTypeTransformer { if (psiMethod.isConstructor()) { Set supertypesJet = Sets.newHashSet(); for (PsiClassType supertype : typeParameter.getExtendsListTypes()) { - supertypesJet.add(transformToType(supertype, UPPER_BOUND, typeVariableResolver)); + supertypesJet.add(transformToType(JavaType.create(supertype), UPPER_BOUND, typeVariableResolver)); } return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet); } @@ -227,7 +228,7 @@ public class JavaTypeTransformer { Variance projectionKind = arrayElementTypeProjectionKind(vararg); TypeUsage howArgumentTypeIsUsed = vararg ? MEMBER_SIGNATURE_CONTRAVARIANT : TYPE_ARGUMENT; - JetType type = transformToType(componentType, howArgumentTypeIsUsed, typeVariableResolver); + JetType type = transformToType(JavaType.create(componentType), howArgumentTypeIsUsed, typeVariableResolver); return TypeUtils.makeNullable(KotlinBuiltIns.getInstance().getArrayType(projectionKind, type)); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java index fb63f22996c..5ed4390ca6e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java @@ -17,15 +17,16 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiEllipsisType; -import com.intellij.psi.PsiParameter; -import com.intellij.psi.PsiType; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; 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.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; +import org.jetbrains.jet.lang.resolve.java.TypeUsage; +import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.java.structure.JavaValueParameter; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -33,10 +34,7 @@ import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; +import java.util.*; public final class JavaValueParameterResolver { private JavaTypeTransformer typeTransformer; @@ -49,21 +47,19 @@ public final class JavaValueParameterResolver { @NotNull DeclarationDescriptor containingDeclaration, int i, @NotNull JavaValueParameter parameter, - @NotNull TypeVariableResolver typeVariableResolver + @NotNull TypeVariableResolver typeVariableResolver, + boolean isVararg ) { - PsiParameter psiParameter = parameter.getPsi(); - - PsiType psiType = psiParameter.getType(); - // TODO: must be very slow, make it lazy? Name name = getParameterName(i, parameter); TypeUsage typeUsage = JavaTypeTransformer - .adjustTypeUsageWithMutabilityAnnotations(psiParameter, TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT); - JetType outType = typeTransformer.transformToType(psiType, typeUsage, typeVariableResolver); + .adjustTypeUsageWithMutabilityAnnotations(parameter.getPsi(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT); + JetType outType = typeTransformer.transformToType(parameter.getType(), typeUsage, typeVariableResolver); JetType varargElementType; - if (psiType instanceof PsiEllipsisType) { + if (isVararg) { + // TODO: test this code varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(TypeUtils.makeNotNullable(outType)); outType = TypeUtils.makeNotNullable(outType); } @@ -73,7 +69,7 @@ public final class JavaValueParameterResolver { JetType transformedType; PsiAnnotation notNullAnnotation = JavaAnnotationResolver - .findAnnotationWithExternal(psiParameter, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION); + .findAnnotationWithExternal(parameter.getPsi(), JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION); if (notNullAnnotation != null) { transformedType = TypeUtils.makeNullableAsSpecified(outType, false); } @@ -105,14 +101,18 @@ public final class JavaValueParameterResolver { @NotNull public JavaDescriptorResolver.ValueParameterDescriptors resolveParameterDescriptors( @NotNull DeclarationDescriptor container, - @NotNull Collection parameters, + @NotNull JavaMethod method, @NotNull TypeVariableResolver typeVariableResolver ) { + Collection parameters = method.getValueParameters(); List result = new ArrayList(parameters.size()); int index = 0; - for (JavaValueParameter parameter : parameters) { - ValueParameterDescriptor parameterDescriptor = resolveParameterDescriptor(container, index, parameter, typeVariableResolver); - result.add(parameterDescriptor); + for (Iterator iterator = parameters.iterator(); iterator.hasNext(); ) { + JavaValueParameter parameter = iterator.next(); + + boolean isVararg = method.isVararg() && !iterator.hasNext(); + ValueParameterDescriptor descriptor = resolveParameterDescriptor(container, index, parameter, typeVariableResolver, isVararg); + result.add(descriptor); index++; } return new JavaDescriptorResolver.ValueParameterDescriptors(null, result); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaArrayType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaArrayType.java new file mode 100644 index 00000000000..3332002a87e --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaArrayType.java @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java.structure; + +import com.intellij.psi.PsiArrayType; +import org.jetbrains.annotations.NotNull; + +public class JavaArrayType extends JavaType { + public JavaArrayType(@NotNull PsiArrayType psiArrayType) { + super(psiArrayType); + } + + @NotNull + @Override + public PsiArrayType getPsi() { + return (PsiArrayType) super.getPsi(); + } + + @NotNull + public JavaType getComponentType() { + return JavaType.create(getPsi().getComponentType()); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java index 95077fa3794..9792a65c95c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClassType.java @@ -27,16 +27,15 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -public class JavaClassType { - private final PsiClassType psiClassType; - +public class JavaClassType extends JavaType { public JavaClassType(@NotNull PsiClassType psiClassType) { - this.psiClassType = psiClassType; + super(psiClassType); } @NotNull + @Override public PsiClassType getPsi() { - return psiClassType; + return (PsiClassType) super.getPsi(); } @Nullable diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java index 0766ad4b171..00e78c18a37 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaField.java @@ -43,4 +43,9 @@ public class JavaField extends JavaMemberImpl { public boolean isEnumEntry() { return getPsi() instanceof PsiEnumConstant; } + + @NotNull + public JavaType getType() { + return JavaType.create(getPsi().getType()); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java index 27baaf323bd..60675098dba 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaMethod.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve.java.structure; import com.intellij.psi.PsiAnnotationMethod; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.name.Name; @@ -72,4 +73,14 @@ public class JavaMethod extends JavaMemberImpl implements JavaTypeParameterListO } return null; } + + @Nullable + public JavaType getReturnType() { + PsiType psiType = getPsi().getReturnType(); + return psiType == null ? null : JavaType.create(psiType); + } + + public boolean isVararg() { + return getPsi().isVarArgs(); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPrimitiveType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPrimitiveType.java new file mode 100644 index 00000000000..1a3086b92fc --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPrimitiveType.java @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java.structure; + +import com.intellij.psi.PsiPrimitiveType; +import org.jetbrains.annotations.NotNull; + +public class JavaPrimitiveType extends JavaType { + public JavaPrimitiveType(@NotNull PsiPrimitiveType psiPrimitiveType) { + super(psiPrimitiveType); + } + + @NotNull + @Override + public PsiPrimitiveType getPsi() { + return (PsiPrimitiveType) super.getPsi(); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java new file mode 100644 index 00000000000..e5da84599f8 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaType.java @@ -0,0 +1,69 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java.structure; + +import com.intellij.psi.*; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +public abstract class JavaType { + private final PsiType psiType; + + public JavaType(@NotNull PsiType psiType) { + this.psiType = psiType; + } + + @NotNull + public PsiType getPsi() { + return psiType; + } + + @NotNull + public static JavaType create(@NotNull PsiType psiType) { + return psiType.accept(new PsiTypeVisitor() { + @Nullable + @Override + public JavaType visitType(PsiType type) { + throw new UnsupportedOperationException("Unsupported PsiType: " + type); + } + + @Nullable + @Override + public JavaType visitPrimitiveType(PsiPrimitiveType primitiveType) { + return new JavaPrimitiveType(primitiveType); + } + + @Nullable + @Override + public JavaType visitArrayType(PsiArrayType arrayType) { + return new JavaArrayType(arrayType); + } + + @Nullable + @Override + public JavaType visitClassType(PsiClassType classType) { + return new JavaClassType(classType); + } + + @Nullable + @Override + public JavaType visitWildcardType(PsiWildcardType wildcardType) { + return new JavaWildcardType(wildcardType); + } + }); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java index 5e9c254a772..5b5a6e912df 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaValueParameter.java @@ -37,4 +37,9 @@ public class JavaValueParameter extends JavaElementImpl { String name = getPsi().getName(); return name == null ? null : Name.identifier(name); } + + @NotNull + public JavaType getType() { + return JavaType.create(getPsi().getType()); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaWildcardType.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaWildcardType.java new file mode 100644 index 00000000000..920f7ab648b --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaWildcardType.java @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java.structure; + +import com.intellij.psi.PsiWildcardType; +import org.jetbrains.annotations.NotNull; + +public class JavaWildcardType extends JavaType { + public JavaWildcardType(@NotNull PsiWildcardType psiWildcardType) { + super(psiWildcardType); + } + + @NotNull + @Override + public PsiWildcardType getPsi() { + return (PsiWildcardType) super.getPsi(); + } +}