Introduce JavaType and subclasses

Use JavaType instead of PsiType whenever possible.

In this commit the logic of checking whether a loaded parameter is a vararg
changed: instead of checking if the corresponding PsiType is PsiEllipsisType we
now check if the containing method has the ACC_VARARG modifier

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) {
+            if (!iterator.hasNext() && returnType instanceof JavaArrayType) {
-                PsiType componentType = ((PsiArrayType) returnType).getComponentType();
+                JavaType componentType = ((JavaArrayType) returnType).getComponentType();
                 varargElementType = typeTransformer.transformToType(componentType, typeVariableResolver);
             }
 
@@ -201,7 +201,7 @@ public final class JavaConstructorResolver {
         List<TypeParameterDescriptor> typeParameters = classDescriptor.getTypeConstructor().getParameters();
 
         JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors(
-                constructorDescriptor, constructor.getValueParameters(),
+                constructorDescriptor, constructor,
                 new TypeVariableResolver(typeParameters, classDescriptor, "constructor of class " + javaClass.getFqName())
         );
 

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();
+        JavaType returnJavaType = method.getReturnType();
-
+        if (returnJavaType == null) {
-        PsiType returnPsiType = psiMethod.getReturnType();
+            // This means that the method is a constructor
-        if (returnPsiType == null) {
             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);
+                .resolveParameterDescriptors(functionDescriptorImpl, method, methodTypeVariableResolver);
-        JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver);
+        JetType returnType = makeReturnType(returnJavaType, method, methodTypeVariableResolver);
 
         List<String> 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
     ) {

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(),

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(upperBound, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver);
-                JetType transformedType = typeTransformer.transformToType(psiClassType, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver);
                 typeParameterDescriptor.addUpperBound(transformedType);
             }
         }

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

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<JetType>() {
+        return javaType.getPsi().accept(new PsiTypeVisitor<JetType>() {
             @Override
             public JetType visitClassType(PsiClassType classType) {
                 PsiClass psiClass = classType.resolve();
@@ -110,7 +111,7 @@ public class JavaTypeTransformer {
                         if (psiMethod.isConstructor()) {
                             Set<JetType> 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));
             }
 

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.*;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
 
 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);
+                .adjustTypeUsageWithMutabilityAnnotations(parameter.getPsi(), TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT);
-        JetType outType = typeTransformer.transformToType(psiType, typeUsage, typeVariableResolver);
+        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<JavaValueParameter> parameters,
+            @NotNull JavaMethod method,
             @NotNull TypeVariableResolver typeVariableResolver
     ) {
+        Collection<JavaValueParameter> parameters = method.getValueParameters();
         List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>(parameters.size());
         int index = 0;
-        for (JavaValueParameter parameter : parameters) {
+        for (Iterator<JavaValueParameter> iterator = parameters.iterator(); iterator.hasNext(); ) {
-            ValueParameterDescriptor parameterDescriptor = resolveParameterDescriptor(container, index, parameter, typeVariableResolver);
+            JavaValueParameter parameter = iterator.next();
-            result.add(parameterDescriptor);
+
+            boolean isVararg = method.isVararg() && !iterator.hasNext();
+            ValueParameterDescriptor descriptor = resolveParameterDescriptor(container, index, parameter, typeVariableResolver, isVararg);
+            result.add(descriptor);
             index++;
         }
         return new JavaDescriptorResolver.ValueParameterDescriptors(null, result);

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

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 {
+public class JavaClassType extends JavaType {
-    private final PsiClassType psiClassType;
-
     public JavaClassType(@NotNull PsiClassType psiClassType) {
-        this.psiClassType = psiClassType;
+        super(psiClassType);
     }
 
     @NotNull
+    @Override
     public PsiClassType getPsi() {
-        return psiClassType;
+        return (PsiClassType) super.getPsi();
     }
 
     @Nullable

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

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

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

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<JavaType>() {
+            @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);
+            }
+        });
+    }
+}

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

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