J2K KotlinLightField: convert and fix compilation

compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightField.kt

@@ -14,177 +14,137 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.asJava;
+package org.jetbrains.kotlin.asJava
 
-import com.intellij.lang.Language;
+import com.intellij.lang.Language
-import com.intellij.lang.java.JavaLanguage;
+import com.intellij.lang.java.JavaLanguage
-import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.TextRange
-import com.intellij.psi.*;
+import com.intellij.psi.*
-import com.intellij.psi.impl.light.LightElement;
+import com.intellij.psi.impl.light.LightElement
-import com.intellij.psi.javadoc.PsiDocComment;
+import com.intellij.psi.javadoc.PsiDocComment
-import com.intellij.psi.search.SearchScope;
+import com.intellij.psi.search.SearchScope
-import com.intellij.util.IncorrectOperationException;
+import com.intellij.util.IncorrectOperationException
-import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NonNls
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.psi.KtDeclaration;
 
 // Copied from com.intellij.psi.impl.light.LightField
-public abstract class KotlinLightField<T extends KtDeclaration, D extends PsiField> extends LightElement
+abstract class KotlinLightField<T : KtDeclaration, D : PsiField>(
-        implements PsiField, KotlinLightElement<T, D> {
+        manager: PsiManager,
-    private final T origin;
+        private val origin: T,
-    private final D delegate;
+        private val delegate: D,
-    private final PsiClass containingClass;
+        private val containingClass: PsiClass
+) : LightElement(manager, JavaLanguage.INSTANCE), PsiField, KotlinLightElement<T, D> {
 
-    public KotlinLightField(@NotNull PsiManager manager, @NotNull T origin, @NotNull D delegate, @NotNull PsiClass containingClass) {
+    abstract override fun copy(): KotlinLightField<T, D>
-        super(manager, JavaLanguage.INSTANCE);
+
-        this.origin = origin;
+    @Throws(IncorrectOperationException::class)
-        this.delegate = delegate;
+    override fun setInitializer(initializer: PsiExpression?) {
-        this.containingClass = containingClass;
+        throw IncorrectOperationException("Not supported")
     }
 
-    @NotNull
+    override fun getUseScope(): SearchScope {
-    @Override
+        return origin.useScope
-    public abstract KotlinLightField<T, D> copy();
-
-    @Override
-    public void setInitializer(@Nullable PsiExpression initializer) throws IncorrectOperationException {
-        throw new IncorrectOperationException("Not supported");
     }
 
-    @NotNull
+    override fun getName(): String? {
-    @Override
+        return delegate.name
-    public SearchScope getUseScope() {
-        return origin.getUseScope();
     }
 
-    @Override
+    override fun getNameIdentifier(): PsiIdentifier {
-    public String getName() {
+        return delegate.nameIdentifier
-        return delegate.getName();
     }
 
-    @NotNull
+    override fun getDocComment(): PsiDocComment? {
-    @Override
+        return delegate.docComment
-    public PsiIdentifier getNameIdentifier() {
-        return delegate.getNameIdentifier();
     }
 
-    @Override
+    override fun isDeprecated(): Boolean {
-    public PsiDocComment getDocComment() {
+        return delegate.isDeprecated
-        return delegate.getDocComment();
     }
 
-    @Override
+    override fun getContainingClass(): PsiClass? {
-    public boolean isDeprecated() {
+        return containingClass
-        return delegate.isDeprecated();
     }
 
-    @Override
+    override fun getType(): PsiType {
-    public PsiClass getContainingClass() {
+        return delegate.type
-        return containingClass;
     }
 
-    @NotNull
+    override fun getTypeElement(): PsiTypeElement? {
-    @Override
+        return delegate.typeElement
-    public PsiType getType() {
-        return delegate.getType();
     }
 
-    @Override
+    override fun getInitializer(): PsiExpression? {
-    public PsiTypeElement getTypeElement() {
+        return delegate.initializer
-        return delegate.getTypeElement();
     }
 
-    @Override
+    override fun hasInitializer(): Boolean {
-    public PsiExpression getInitializer() {
+        return delegate.hasInitializer()
-        return delegate.getInitializer();
     }
 
-    @Override
+    @Throws(IncorrectOperationException::class)
-    public boolean hasInitializer() {
+    override fun normalizeDeclaration() {
-        return delegate.hasInitializer();
+        throw IncorrectOperationException("Not supported")
     }
 
-    @Override
+    override fun computeConstantValue(): Any? {
-    public void normalizeDeclaration() throws IncorrectOperationException {
+        return delegate.computeConstantValue()
-        throw new IncorrectOperationException("Not supported");
     }
 
-    @Override
+    @Throws(IncorrectOperationException::class)
-    public Object computeConstantValue() {
+    override fun setName(@NonNls name: String): PsiElement {
-        return delegate.computeConstantValue();
+        throw IncorrectOperationException("Not supported")
     }
 
-    @Override
+    override fun getModifierList(): PsiModifierList? {
-    public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
+        return delegate.modifierList
-        throw new IncorrectOperationException("Not supported");
     }
 
-    @Override
+    override fun hasModifierProperty(@NonNls name: String): Boolean {
-    public PsiModifierList getModifierList() {
+        return delegate.hasModifierProperty(name)
-        return delegate.getModifierList();
     }
 
-    @Override
+    override fun getText(): String {
-    public boolean hasModifierProperty(@NonNls @NotNull String name) {
+        return delegate.text
-        return delegate.hasModifierProperty(name);
     }
 
-    @Override
+    override fun getTextRange(): TextRange {
-    public String getText() {
+        return TextRange(-1, -1)
-        return delegate.getText();
     }
 
-    @Override
+    override fun isValid(): Boolean {
-    public TextRange getTextRange() {
+        return containingClass.isValid
-        return new TextRange(-1, -1);
     }
 
-    @Override
+    override fun toString(): String {
-    public boolean isValid() {
+        return "KotlinLightField:" + name!!
-        return containingClass.isValid();
     }
 
-    @Override
+    override fun getOrigin(): T {
-    public String toString() {
+        return origin
-        return "KotlinLightField:" + getName();
     }
 
-    @NotNull
+    override fun getDelegate(): D {
-    @Override
+        return delegate
-    public T getOrigin() {
-        return origin;
     }
 
-    @NotNull
+    override fun getNavigationElement(): PsiElement {
-    @Override
+        return getOrigin()
-    public D getDelegate() {
-        return delegate;
     }
 
-    @NotNull
+    override fun getLanguage(): Language {
-    @Override
+        return KotlinLanguage.INSTANCE
-    public PsiElement getNavigationElement() {
-        return getOrigin();
     }
 
-    @NotNull
+    override fun isEquivalentTo(another: PsiElement?): Boolean {
-    @Override
+        if (another is KotlinLightField<*, *> && origin.isEquivalentTo(another.getOrigin())) {
-    public Language getLanguage() {
+            return true
-        return KotlinLanguage.INSTANCE;
-    }
-
-    @Override
-    public boolean isEquivalentTo(PsiElement another) {
-        if (another instanceof KotlinLightField && origin.isEquivalentTo(((KotlinLightField) another).getOrigin())) {
-            return true;
         }
-        return super.isEquivalentTo(another);
+        return super.isEquivalentTo(another)
     }
 
-    @Override
+    override fun isWritable(): Boolean {
-    public boolean isWritable() {
+        return getOrigin().isWritable
-        return getOrigin().isWritable();
     }
 }