J2K: extract base class for Parameter

j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt

@@ -209,12 +209,12 @@ class ConstructorConverter(
                             Modifiers(listOf()).with(fieldCorrection.access).assignNoPrototype()
                         else
                             converter.convertModifiers(field).filter { it in ACCESS_MODIFIERS }
-                        Parameter(name,
-                                  type,
-                                  if (field.isVal(converter.referenceSearcher)) Parameter.VarValModifier.Val else Parameter.VarValModifier.Var,
+                        FunctionParameter(name,
+                                          type,
+                                          if (field.isVal(converter.referenceSearcher)) FunctionParameter.VarValModifier.Val else FunctionParameter.VarValModifier.Var,
                                   converter.convertAnnotations(parameter) + converter.convertAnnotations(field),
-                                  accessModifiers,
-                                  default)
+                                          accessModifiers,
+                                          default)
                                 .assignPrototypes(
                                         PrototypeInfo(parameter, CommentsAndSpacesInheritance.LINE_BREAKS),
                                         PrototypeInfo(field, CommentsAndSpacesInheritance.NO_SPACES)

j2k/src/org/jetbrains/kotlin/j2k/Converter.kt

@@ -236,15 +236,15 @@ class Converter private constructor(
         val annotationMethods = psiClass.getMethods().filterIsInstance<PsiAnnotationMethod>()
         val (methodsNamedValue, otherMethods) = annotationMethods.partition { it.getName() == "value" }
 
-        fun createParameter(type: Type, method: PsiAnnotationMethod): Parameter {
+        fun createParameter(type: Type, method: PsiAnnotationMethod): FunctionParameter {
             type.assignPrototype(method.getReturnTypeElement(), CommentsAndSpacesInheritance.NO_SPACES)
 
-            return Parameter(method.declarationIdentifier(),
-                      type,
-                      Parameter.VarValModifier.Val,
-                      convertAnnotations(method),
-                      paramModifiers,
-                      annotationConverter.convertAnnotationMethodDefault(method)).assignPrototype(method, CommentsAndSpacesInheritance.NO_SPACES)
+            return FunctionParameter(method.declarationIdentifier(),
+                                     type,
+                                     FunctionParameter.VarValModifier.Val,
+                                     convertAnnotations(method),
+                                     paramModifiers,
+                                     annotationConverter.convertAnnotationMethodDefault(method)).assignPrototype(method, CommentsAndSpacesInheritance.NO_SPACES)
         }
 
         fun convertType(psiType: PsiType?): Type {
@@ -427,7 +427,7 @@ class Converter private constructor(
                                       newLineAfter = false).assignNoPrototype())).assignNoPrototype()
         }
 
-        if (function.parameterList.parameters.any { it.defaultValue != null } && !function.modifiers.isPrivate) {
+        if (function.parameterList.parameters.any { it is FunctionParameter && it.defaultValue != null } && !function.modifiers.isPrivate) {
             function.annotations += Annotations(
                     listOf(Annotation(Identifier("jvmOverloads").assignNoPrototype(),
                                       listOf(),
@@ -535,17 +535,17 @@ class Converter private constructor(
     public fun convertParameter(
             parameter: PsiParameter,
             nullability: Nullability = Nullability.Default,
-            varValModifier: Parameter.VarValModifier = Parameter.VarValModifier.None,
+            varValModifier: FunctionParameter.VarValModifier = FunctionParameter.VarValModifier.None,
             modifiers: Modifiers = Modifiers.Empty,
             defaultValue: DeferredElement<Expression>? = null
-    ): Parameter {
+    ): FunctionParameter {
         var type = typeConverter.convertVariableType(parameter)
         when (nullability) {
             Nullability.NotNull -> type = type.toNotNullType()
             Nullability.Nullable -> type = type.toNullableType()
         }
-        return Parameter(parameter.declarationIdentifier(), type, varValModifier,
-                         convertAnnotations(parameter), modifiers, defaultValue).assignPrototype(parameter, CommentsAndSpacesInheritance.LINE_BREAKS)
+        return FunctionParameter(parameter.declarationIdentifier(), type, varValModifier,
+                                 convertAnnotations(parameter), modifiers, defaultValue).assignPrototype(parameter, CommentsAndSpacesInheritance.LINE_BREAKS)
     }
 
     public fun convertIdentifier(identifier: PsiIdentifier?): Identifier {

j2k/src/org/jetbrains/kotlin/j2k/OverloadReducer.kt

@@ -178,7 +178,7 @@ class OverloadReducer(
 public fun Converter.convertParameterList(
         method: PsiMethod,
         overloadReducer: OverloadReducer?,
-        convertParameter: (parameter: PsiParameter, default: DeferredElement<Expression>?) -> Parameter = { parameter, default -> convertParameter(parameter, defaultValue = default) },
+        convertParameter: (parameter: PsiParameter, default: DeferredElement<Expression>?) -> FunctionParameter = { parameter, default -> convertParameter(parameter, defaultValue = default) },
         correctCodeConverter: CodeConverter.() -> CodeConverter = { this }
 ): ParameterList {
     val parameterList = method.getParameterList()

j2k/src/org/jetbrains/kotlin/j2k/StatementConverter.kt

@@ -204,11 +204,11 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
                 listOf(parameterType)
             for (t in types) {
                 var convertedType = codeConverter.typeConverter.convertType(t, Nullability.NotNull)
-                val convertedParameter = Parameter(parameter.declarationIdentifier(),
-                                                   convertedType,
-                                                   Parameter.VarValModifier.None,
-                                                   annotations,
-                                                   Modifiers.Empty).assignPrototype(parameter)
+                val convertedParameter = FunctionParameter(parameter.declarationIdentifier(),
+                                                           convertedType,
+                                                           FunctionParameter.VarValModifier.None,
+                                                           annotations,
+                                                           Modifiers.Empty).assignPrototype(parameter)
                 catches.add(CatchStatement(convertedParameter, blockConverted).assignNoPrototype())
             }
         }

j2k/src/org/jetbrains/kotlin/j2k/ast/Parameter.kt

@@ -18,12 +18,15 @@ package org.jetbrains.kotlin.j2k.ast
 
 import org.jetbrains.kotlin.j2k.*
 
-class Parameter(val identifier: Identifier,
-                val type: Type,
-                val varVal: Parameter.VarValModifier,
-                val annotations: Annotations,
-                val modifiers: Modifiers,
-                val defaultValue: DeferredElement<Expression>? = null) : Element() {
+abstract class Parameter(val identifier: Identifier,
+                         val type: Type?): Element()
+
+class FunctionParameter(identifier: Identifier,
+                        type: Type,
+                        val varVal: FunctionParameter.VarValModifier,
+                        val annotations: Annotations,
+                        val modifiers: Modifiers,
+                        val defaultValue: DeferredElement<Expression>? = null) : Parameter(identifier, type) {
     public enum class VarValModifier {
         None,
         Val,
@@ -42,7 +45,7 @@ class Parameter(val identifier: Identifier,
             VarValModifier.Val -> builder.append("val ")
         }
 
-        builder append identifier append ":" append type
+        builder append identifier append ":" append type!!
 
         if (defaultValue != null) {
             builder append " = " append defaultValue

j2k/src/org/jetbrains/kotlin/j2k/ast/Statements.kt

@@ -133,7 +133,7 @@ class ThrowStatement(val expression: Expression) : Expression() {
     }
 }
 
-class CatchStatement(val variable: Parameter, val block: Block) : Statement() {
+class CatchStatement(val variable: FunctionParameter, val block: Block) : Statement() {
     override fun generateCode(builder: CodeBuilder) {
         builder append "catch (" append variable append ") " append block
     }