sync code from IntelliJ-EmmyLua

Author: tangzx

EmmyLua-Common/src/main/java/com/tang/intellij/lua/ty/TyArray.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2017. tangzx([email protected])
+ *
+ * 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 com.tang.intellij.lua.ty
+
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import com.tang.intellij.lua.search.SearchContext
+
+interface ITyArray : ITy {
+    val base: ITy
+}
+
+class TyArray(override val base: ITy) : Ty(TyKind.Array), ITyArray {
+
+    override fun equals(other: Any?): Boolean {
+        return other is ITyArray && base == other.base
+    }
+
+    override fun hashCode(): Int {
+        return displayName.hashCode()
+    }
+
+    override fun subTypeOf(other: ITy, context: SearchContext, strict: Boolean): Boolean {
+        return super.subTypeOf(other, context, strict) || (other is TyArray && base.subTypeOf(other.base, context, strict)) || other == TABLE
+    }
+
+    override fun substitute(substitutor: ITySubstitutor): ITy {
+        return TyArray(base.substitute(substitutor))
+    }
+
+    override fun accept(visitor: ITyVisitor) {
+        visitor.visitArray(this)
+    }
+
+    override fun acceptChildren(visitor: ITyVisitor) {
+        base.accept(visitor)
+    }
+}
+
+object TyArraySerializer : TySerializer<ITyArray>() {
+    override fun serializeTy(ty: ITyArray, stream: StubOutputStream) {
+        Ty.serialize(ty.base, stream)
+    }
+
+    override fun deserializeTy(flags: Int, stream: StubInputStream): ITyArray {
+        val base = Ty.deserialize(stream)
+        return TyArray(base)
+    }
+}

EmmyLua-Common/src/main/java/com/tang/intellij/lua/ty/TySerializer.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017. tangzx([email protected])
+ *
+ * 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 com.tang.intellij.lua.ty
+
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+
+interface ITySerializer {
+    fun serialize(ty: ITy, stream: StubOutputStream)
+    fun deserialize(flags: Int, stream: StubInputStream): ITy
+}
+
+abstract class TySerializer<T : ITy> : ITySerializer {
+    override fun serialize(ty: ITy, stream: StubOutputStream) {
+        @Suppress("UNCHECKED_CAST")
+        val t = ty as T
+        serializeTy(t, stream)
+    }
+
+    override fun deserialize(flags: Int, stream: StubInputStream): ITy {
+        return deserializeTy(flags, stream)
+    }
+
+    abstract fun deserializeTy(flags: Int, stream: StubInputStream): T
+
+    protected abstract fun serializeTy(ty: T, stream: StubOutputStream)
+}

EmmyLua-Common/src/main/java/com/tang/intellij/lua/ty/TyTuple.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2017. tangzx([email protected])
+ *
+ * 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 com.tang.intellij.lua.ty
+
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import com.tang.intellij.lua.search.SearchContext
+
+class TyTuple(val list: List<ITy>) : Ty(TyKind.Tuple) {
+
+    val size: Int get() {
+        return list.size
+    }
+
+    override fun substitute(substitutor: ITySubstitutor): ITy {
+        val list = list.map { it.substitute(substitutor) }
+        return TyTuple(list)
+    }
+
+    override fun accept(visitor: ITyVisitor) {
+        visitor.visitTuple(this)
+    }
+
+    override fun acceptChildren(visitor: ITyVisitor) {
+        list.forEach { it.accept(visitor) }
+    }
+
+    override fun subTypeOf(other: ITy, context: SearchContext, strict: Boolean): Boolean {
+        if (other is TyTuple && other.size == size) {
+            for (i in 0 until size) {
+                if (!list[i].subTypeOf(other.list[i], context, strict)) {
+                    return false
+                }
+            }
+            return true
+        }
+        return false
+    }
+
+    override fun hashCode(): Int {
+        var hash = 0
+        for (ty in list) {
+            hash = hash * 31 + ty.hashCode()
+        }
+        return hash
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (other is TyTuple && other.size == size) {
+            for (i in 0 until size) {
+                if (list[i] != other.list[i]) {
+                    return false
+                }
+            }
+            return true
+        }
+        return super.equals(other)
+    }
+}
+
+object TyTupleSerializer : TySerializer<TyTuple>() {
+    override fun deserializeTy(flags: Int, stream: StubInputStream): TyTuple {
+        val size = stream.readByte().toInt()
+        val list = mutableListOf<ITy>()
+        for (i in 0 until size) list.add(Ty.deserialize(stream))
+        return TyTuple(list)
+    }
+
+    override fun serializeTy(ty: TyTuple, stream: StubOutputStream) {
+        stream.writeByte(ty.list.size)
+        ty.list.forEach { Ty.serialize(it, stream) }
+    }
+}

EmmyLua-Common/src/main/java/com/tang/intellij/lua/ty/TyUnion.kt

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2017. tangzx([email protected])
+ *
+ * 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 com.tang.intellij.lua.ty
+
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import com.tang.intellij.lua.search.SearchContext
+
+class TyUnion : Ty(TyKind.Union) {
+    private val childSet = mutableSetOf<ITy>()
+
+    fun getChildTypes() = childSet
+
+    val size:Int
+        get() = childSet.size
+
+    fun append(ty: ITy): TyUnion {
+        if (ty is TyUnion) {
+            ty.childSet.forEach { addChild(it) }
+        }
+        else addChild(ty)
+        return this
+    }
+
+    private fun addChild(ty: ITy): Boolean {
+        return childSet.add(ty)
+    }
+
+    override fun subTypeOf(other: ITy, context: SearchContext, strict: Boolean): Boolean {
+        return super.subTypeOf(other, context, strict) || childSet.any { type -> type.subTypeOf(other, context, strict) }
+    }
+
+    override fun substitute(substitutor: ITySubstitutor): ITy {
+        val u = TyUnion()
+        childSet.forEach { u.append(it.substitute(substitutor)) }
+        return u
+    }
+
+    override fun accept(visitor: ITyVisitor) {
+        visitor.visitUnion(this)
+    }
+
+    override fun acceptChildren(visitor: ITyVisitor) {
+        childSet.forEach { it.accept(visitor) }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        return other is TyUnion && other.hashCode() == hashCode()
+    }
+
+    override fun hashCode(): Int {
+        var code = 0
+        childSet.forEach { code = code * 31 + it.hashCode() }
+        return code
+    }
+
+    companion object {
+        fun <T : ITy> find(ty: ITy, clazz: Class<T>): T? {
+            if (clazz.isInstance(ty))
+                return clazz.cast(ty)
+            var ret: T? = null
+            process(ty) {
+                if (clazz.isInstance(it)) {
+                    ret = clazz.cast(it)
+                    return@process false
+                }
+                true
+            }
+            return ret
+        }
+
+        fun process(ty: ITy, process: (ITy) -> Boolean) {
+            if (ty is TyUnion) {
+                // why nullable ???
+                val arr: Array<ITy?> = ty.childSet.toTypedArray()
+                for (child in arr) {
+                    if (child != null && !process(child))
+                        break
+                }
+            } else process(ty)
+        }
+
+        fun each(ty: ITy, fn: (ITy) -> Unit) {
+            process(ty) {
+                fn(it)
+                true
+            }
+        }
+
+        // used by ver.2017
+        @Suppress("unused")
+        fun eachPerfect(ty: ITy, process: (ITy) -> Boolean) {
+            if (ty is TyUnion) {
+                val list = ty.childSet.sorted()
+                for (iTy in list) {
+                    if (!process(iTy))
+                        break
+                }
+            } else process(ty)
+        }
+
+        fun union(t1: ITy, t2: ITy): ITy {
+            return when {
+                isInvalid(t1) -> t2
+                isInvalid(t2) -> t1
+                t1 is TyUnion -> t1.append(t2)
+                t2 is TyUnion -> t2.append(t1)
+                else -> {
+                    val u = TyUnion()
+                    u.addChild(t1)
+                    u.addChild(t2)
+                    //if t1 == t2
+                    if (u.childSet.size == 1) t1 else u
+                }
+            }
+        }
+
+        fun getPerfectClass(ty: ITy): ITyClass? {
+            var clazz: ITyClass? = null
+            var anonymous: ITyClass? = null
+            var global: ITyClass? = null
+            process(ty) {
+                if (it is ITyClass) {
+                    when {
+                        it.isAnonymous -> anonymous = it
+                        it.isGlobal -> global = it
+                        else -> clazz = it
+                    }
+                }
+                clazz == null
+            }
+            return clazz ?: global ?: anonymous
+        }
+    }
+}
+
+object TyUnionSerializer : TySerializer<TyUnion>() {
+    override fun serializeTy(ty: TyUnion, stream: StubOutputStream) {
+        stream.writeInt(ty.size)
+        TyUnion.each(ty) { Ty.serialize(it, stream) }
+    }
+
+    override fun deserializeTy(flags: Int, stream: StubInputStream): TyUnion {
+        val union = TyUnion()
+        val size = stream.readInt()
+        for (i in 0 until size) {
+            union.append(Ty.deserialize(stream))
+        }
+        return union
+    }
+}