arkanalyzer 1.0.93 → 2.0.0-beta1

package/lib/core/base/Type.js

@@ -13,15 +13,71 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumValueType = exports.LexicalEnvType = exports.AnnotationTypeQueryType = exports.AnnotationNamespaceType = exports.AnnotationType = exports.GenericType = exports.AliasType = exports.TupleType = exports.ArrayType = exports.ClassType = exports.ClosureType = exports.FunctionType = exports.NeverType = exports.VoidType = exports.IntersectionType = exports.UnionType = exports.LiteralType = exports.UndefinedType = exports.NullType = exports.StringType = exports.BigIntType = exports.NumberType = exports.BooleanType = exports.PrimitiveType = exports.UnclearReferenceType = exports.UnknownType = exports.AnyType = exports.Type = void 0;
+exports.EnumValueType = exports.LexicalEnvType = exports.AnnotationTypeQueryType = exports.AnnotationNamespaceType = exports.AnnotationType = exports.GenericType = exports.AliasType = exports.TupleType = exports.ArrayType = exports.ClassType = exports.ClosureType = exports.FunctionType = exports.NeverType = exports.VoidType = exports.IntersectionType = exports.UnionType = exports.LiteralType = exports.UndefinedType = exports.NullType = exports.StringType = exports.BigIntType = exports.NumberType = exports.BooleanType = exports.PrimitiveType = exports.UnclearReferenceType = exports.UnknownType = exports.AnyType = exports.Type = exports.ArrayUnclearVisited = void 0;
 const ArkSignature_1 = require("../model/ArkSignature");
 const ArkExport_1 = require("../model/ArkExport");
 const ArkBaseModel_1 = require("../model/ArkBaseModel");
 const TSConst_1 = require("../common/TSConst");
-/**
- * @category core/base/type
- */
+const SignatureCanonicalizerRegistry_1 = require("../common/SignatureCanonicalizerRegistry");
+const logger_1 = __importStar(require("../../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Type');
+class ArrayUnclearVisited {
+    constructor() {
+        this.items = [];
+        this.base = 0;
+        this.top = 0;
+    }
+    enter() {
+        const prev = this.base;
+        this.base = this.top;
+        return prev;
+    }
+    has(type) {
+        for (let i = this.base; i < this.top; i++) {
+            if (this.items[i] === type) {
+                return true;
+            }
+        }
+        return false;
+    }
+    add(type) {
+        this.items[this.top++] = type;
+    }
+    leave(prevBase) {
+        const nullType = null;
+        for (let i = this.base; i < this.top; i++) {
+            this.items[i] = nullType;
+        }
+        this.top = this.base;
+        this.base = prevBase;
+    }
+}
+exports.ArrayUnclearVisited = ArrayUnclearVisited;
+const unclearVisited = new ArrayUnclearVisited();
 class Type {
     /** True if this type can contain other types and thus participate in cycles */
     canParticipateInCycle() {
@@ -64,6 +120,15 @@ class Type {
             }
         }
     }
+    isUnclear() {
+        const prevBase = unclearVisited.enter();
+        try {
+            return this.isUnclearWithVisited(unclearVisited);
+        }
+        finally {
+            unclearVisited.leave(prevBase);
+        }
+    }
 }
 exports.Type = Type;
 /**
@@ -77,6 +142,9 @@ class AnyType extends Type {
     constructor() {
         super();
     }
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
         return TSConst_1.ANY_KEYWORD;
     }
@@ -94,6 +162,9 @@ class UnknownType extends Type {
     constructor() {
         super();
     }
+    isUnclearWithVisited(_visited) {
+        return true;
+    }
     getTypeString(_visited) {
         return TSConst_1.UNKNOWN_KEYWORD;
     }
@@ -122,6 +193,9 @@ class UnclearReferenceType extends Type {
     getGenericTypes() {
         return this.genericTypes;
     }
+    isUnclearWithVisited(_visited) {
+        return true;
+    }
     getTypeString(visited = new Set()) {
         let str = this.name;
         if (this.genericTypes.length > 0) {
@@ -143,6 +217,11 @@ class PrimitiveType extends Type {
     getName() {
         return this.name;
     }
+    // Transit implementation: concrete primitives are never unclear;
+    // only the inherently unclear leaves (see NullType/UndefinedType notes) override isUnclearWithVisited.
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
         return this.name;
     }
@@ -207,6 +286,10 @@ class NullType extends PrimitiveType {
     constructor() {
         super(TSConst_1.NULL_KEYWORD);
     }
+    isUnclearWithVisited(_visited) {
+        // UNIFY-EXP: null as concrete
+        return false;
+    }
 }
 exports.NullType = NullType;
 NullType.INSTANCE = new NullType();
@@ -221,6 +304,10 @@ class UndefinedType extends PrimitiveType {
     constructor() {
         super(TSConst_1.UNDEFINED_KEYWORD);
     }
+    isUnclearWithVisited(_visited) {
+        // UNIFY-EXP: undefined as concrete
+        return false;
+    }
 }
 exports.UndefinedType = UndefinedType;
 UndefinedType.INSTANCE = new UndefinedType();
@@ -265,6 +352,20 @@ class UnionType extends Type {
     setCurrType(newType) {
         this.currType = newType;
     }
+    isUnclearWithVisited(visited) {
+        if (visited.has(this)) {
+            return false;
+        }
+        visited.add(this);
+        // Unified full semantics: a union is unclear iff any member is unclear.
+        const memberTypes = this.getTypes();
+        for (let i = 0; i < memberTypes.length; i++) {
+            if (memberTypes[i].isUnclearWithVisited(visited)) {
+                return true;
+            }
+        }
+        return false;
+    }
     getTypeString(visited = new Set()) {
         const typesString = [];
         this.getTypes().forEach(t => {
@@ -307,6 +408,20 @@ class IntersectionType extends Type {
     getTypes() {
         return this.types;
     }
+    isUnclearWithVisited(visited) {
+        if (visited.has(this)) {
+            return false;
+        }
+        visited.add(this);
+        // Unified full semantics (see UnionType).
+        const memberTypes = this.getTypes();
+        for (let i = 0; i < memberTypes.length; i++) {
+            if (memberTypes[i].isUnclearWithVisited(visited)) {
+                return true;
+            }
+        }
+        return false;
+    }
     getTypeString(visited = new Set()) {
         const typesString = [];
         this.getTypes().forEach(t => {
@@ -332,6 +447,9 @@ class VoidType extends Type {
     constructor() {
         super();
     }
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
         return TSConst_1.VOID_KEYWORD;
     }
@@ -349,6 +467,9 @@ class NeverType extends Type {
     constructor() {
         super();
     }
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
         return TSConst_1.NEVER_KEYWORD;
     }
@@ -365,20 +486,74 @@ class FunctionType extends Type {
     }
     constructor(methodSignature, realGenericTypes) {
         super();
-        this.methodSignature = methodSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (methodSignature.isUnclear()) {
+            this.methodSigID = -1;
+            this.tempSigID = reg.tempMethodSigCanonicalizer.register(methodSignature);
+        }
+        else {
+            const existingId = reg.methodSigCanonicalizer.getExistingId(methodSignature);
+            if (existingId !== -1) {
+                this.methodSigID = existingId;
+                this.tempSigID = undefined;
+            }
+            else {
+                logger.error(`FunctionType: clear MethodSignature not interned — routing to temp defensively: ${methodSignature.toString()}`);
+                this.methodSigID = -1;
+                this.tempSigID = reg.tempMethodSigCanonicalizer.register(methodSignature);
+            }
+        }
         this.realGenericTypes = realGenericTypes;
     }
     getMethodSignature() {
-        return this.methodSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (this.methodSigID >= 0) {
+            return reg.methodSigCanonicalizer.get(this.methodSigID);
+        }
+        if (this.tempSigID !== undefined) {
+            const sig = reg.tempMethodSigCanonicalizer.get(this.tempSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+            // 惰性物化：已迁移 → 替换记录直达 formal（tempSigID 保留作痕迹）。
+            const formalId = reg.tempMethodSigCanonicalizer.getReplacement(this.tempSigID);
+            if (formalId !== -1) {
+                const formalSig = reg.methodSigCanonicalizer.get(formalId);
+                if (formalSig !== undefined) {
+                    this.methodSigID = formalId;
+                    return formalSig;
+                }
+            }
+        }
+        throw new Error('FunctionType has no signature');
+    }
+    /** @internal Get the formal MethodSigID. */
+    getMethodSigID() {
+        return this.methodSigID;
+    }
+    /** @internal Get the temp sigID for the unresolved-signature registration. */
+    getTempSigID() {
+        return this.tempSigID;
     }
     getRealGenericTypes() {
         return this.realGenericTypes;
     }
+    isUnclearWithVisited(_visited) {
+        // 恒为 false，三层理由：
+        // 1. 语义层：FunctionType 表示函数类型本身（结构描述：参数列表+返回类型），不是对函数实体的引用——"引用可解析性"的判定职责由 ClassType 承担。
+        //    "该签名对应哪个真实方法"的解析在消费点有专门机制（canonicalizer 值查找 + fallback 遍历），从不依赖本判定。
+        // 2. 结构层：ClassType 的检查项（%unk stub 文件、PROMISE 无泛型）各对应一种真实残缺形态（temp 兜底、未定型泛型）；
+        //    而 MethodSignature 永远是完整值——即使声明方 unclear，签名作为值（名字+参数+返回类型）仍然完整，构造时总能 intern。函数类型没有"残缺形态"需要暴露。
+        // 3. 实证：泛型实参传播版（Fn<Unclear> 判 true）曾被全量回归否决（keyof-typeof 推导链退化），勿再尝试。
+        //    函数内容的不确定性（参数/返回/泛型实参）由消费点按需处理，类型层传播已被实证会破坏推导链。
+        return false;
+    }
     getTypeString(visited = new Set()) {
-        const sig = this.methodSignature.getMethodSubSignature();
-        const classStr = this.methodSignature.getDeclaringClassSignature().toString();
-        const paramStrs = sig.getParameterTypes()
-            .map(t => t ? t.toStringWithVisited(visited) : UnknownType.getInstance().toString())
+        const sig = this.getMethodSignature().getMethodSubSignature();
+        const classStr = this.getMethodSignature().getDeclaringClassSignature().toString();
+        const paramStrs = sig
+            .getParameterTypes()
+            .map(t => (t ? t.toStringWithVisited(visited) : UnknownType.getInstance().toString()))
             .join(', ');
         const methodPart = (sig.isStatic() ? '[static]' : '') + sig.getMethodName() + '(' + paramStrs + ')';
         return classStr + '.' + methodPart;
@@ -411,18 +586,78 @@ class ClassType extends Type {
         return true;
     }
     getDisplayNameForCycle() {
-        return this.classSignature.toString();
+        return this.getClassSignature().toString();
     }
     constructor(classSignature, realGenericTypes) {
         super();
-        this.classSignature = classSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (classSignature.isUnclear()) {
+            this.classSigID = -1;
+            this.tempSigID = reg.tempClassSigCanonicalizer.register(classSignature);
+        }
+        else {
+            const existingId = reg.classSigCanonicalizer.getExistingId(classSignature);
+            if (existingId !== -1) {
+                this.classSigID = existingId;
+            }
+            else {
+                logger.error(`ClassType: clear ClassSignature not interned — routing to temp defensively: ${classSignature.toString()}`);
+                this.classSigID = -1;
+                this.tempSigID = reg.tempClassSigCanonicalizer.register(classSignature);
+            }
+        }
         this.realGenericTypes = realGenericTypes;
     }
     getClassSignature() {
-        return this.classSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (this.classSigID >= 0) {
+            return reg.classSigCanonicalizer.get(this.classSigID);
+        }
+        if (this.tempSigID !== undefined) {
+            const sig = reg.tempClassSigCanonicalizer.get(this.tempSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+            // 惰性物化：已迁移（slot 置空）→ 替换记录直达 formal（"下一处直接使用 formal ID"）；tempSigID 保留作"曾 temp"审计痕迹。
+            const formalId = reg.tempClassSigCanonicalizer.getReplacement(this.tempSigID);
+            if (formalId !== -1) {
+                const formalSig = reg.classSigCanonicalizer.get(formalId);
+                if (formalSig !== undefined) {
+                    this.classSigID = formalId;
+                    return formalSig;
+                }
+            }
+        }
+        throw new Error('ClassType has no signature');
     }
     setClassSignature(newClassSignature) {
-        this.classSignature = newClassSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (newClassSignature.isUnclear()) {
+            this.classSigID = -1;
+            this.tempSigID = reg.tempClassSigCanonicalizer.register(newClassSignature);
+            return;
+        }
+        const existingId = reg.classSigCanonicalizer.getExistingId(newClassSignature);
+        if (existingId !== -1) {
+            if (this.tempSigID !== undefined) {
+                reg.tempClassSigCanonicalizer.retireWithReplacement(this.tempSigID, existingId);
+            }
+            this.classSigID = existingId;
+            this.tempSigID = undefined;
+        }
+        else {
+            logger.error(`ClassType: clear ClassSignature not interned (setClassSignature) — routing to temp defensively: ${newClassSignature.toString()}`);
+            this.classSigID = -1;
+            this.tempSigID = reg.tempClassSigCanonicalizer.register(newClassSignature);
+        }
+    }
+    /** @internal Get the formal ClassSigID. */
+    getClassSigID() {
+        return this.classSigID;
+    }
+    /** @internal Get the temp sigID for the unresolved-signature registration. */
+    getTempSigID() {
+        return this.tempSigID;
     }
     getRealGenericTypes() {
         return this.realGenericTypes;
@@ -430,8 +665,15 @@ class ClassType extends Type {
     setRealGenericTypes(types) {
         this.realGenericTypes = types;
     }
+    isUnclearWithVisited(_visited) {
+        const classSignature = this.getClassSignature();
+        if (classSignature.getDeclaringFileSigID() === 0) {
+            return true;
+        }
+        return classSignature.getClassName() === TSConst_1.PROMISE && !this.getRealGenericTypes();
+    }
     getTypeString(visited = new Set()) {
-        let temp = this.classSignature.toString();
+        let temp = this.getClassSignature().toString();
         if (this.realGenericTypes && this.realGenericTypes.length > 0) {
             temp += `<${this.realGenericTypes.map(t => t.toStringWithVisited(visited)).join(',')}>`;
         }
@@ -480,6 +722,14 @@ class ArrayType extends Type {
     getReadonlyFlag() {
         return this.readonlyFlag;
     }
+    isUnclearWithVisited(visited) {
+        if (visited.has(this)) {
+            return false;
+        }
+        visited.add(this);
+        // Unified full semantics: the array is unclear iff its base type is unclear.
+        return this.getBaseType().isUnclearWithVisited(visited);
+    }
     getTypeString(visited = new Set()) {
         const strs = [];
         if (this.getReadonlyFlag()) {
@@ -530,6 +780,20 @@ class TupleType extends Type {
     getReadonlyFlag() {
         return this.readonlyFlag;
     }
+    isUnclearWithVisited(visited) {
+        if (visited.has(this)) {
+            return false;
+        }
+        visited.add(this);
+        // Unified full semantics (see UnionType).
+        const memberTypes = this.getTypes();
+        for (let i = 0; i < memberTypes.length; i++) {
+            if (memberTypes[i].isUnclearWithVisited(visited)) {
+                return true;
+            }
+        }
+        return false;
+    }
     getTypeString(visited = new Set()) {
         const typesStr = this.types.map(t => t.toStringWithVisited(visited)).join(', ');
         if (this.getReadonlyFlag()) {
@@ -580,6 +844,14 @@ class AliasType extends Type {
     getOriginalType() {
         return this.originalType;
     }
+    isUnclearWithVisited(visited) {
+        if (visited.has(this)) {
+            return false;
+        }
+        visited.add(this);
+        // The alias propagates the unclear semantics of its original type.
+        return this.getOriginalType().isUnclearWithVisited(visited);
+    }
     getTypeString(visited = new Set()) {
         let res = this.getSignature().toString(visited);
         const realGeneric = this.getRealGenericTypes();
@@ -674,6 +946,9 @@ class GenericType extends Type {
         var _a;
         return (_a = this.index) !== null && _a !== void 0 ? _a : 0;
     }
+    isUnclearWithVisited(_visited) {
+        return true;
+    }
     getTypeString(visited = new Set()) {
         let str = this.name;
         if (this.constraint) {
@@ -694,6 +969,10 @@ class AnnotationType extends Type {
     getOriginType() {
         return this.originType;
     }
+    // Transit implementation: annotation types are concrete leaf types
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
         return this.originType;
     }
@@ -729,11 +1008,54 @@ exports.AnnotationTypeQueryType = AnnotationTypeQueryType;
 class LexicalEnvType extends Type {
     constructor(nestedMethod, closures) {
         super();
-        this.nestedMethodSignature = nestedMethod;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (nestedMethod.isUnclear()) {
+            this.nestedMethodSigID = -1;
+            this.tempSigID = reg.tempMethodSigCanonicalizer.register(nestedMethod);
+        }
+        else {
+            const existingId = reg.methodSigCanonicalizer.getExistingId(nestedMethod);
+            if (existingId !== -1) {
+                this.nestedMethodSigID = existingId;
+                this.tempSigID = undefined;
+            }
+            else {
+                logger.error(`LexicalEnvType: clear MethodSignature not interned — routing to temp defensively: ${nestedMethod.toString()}`);
+                this.nestedMethodSigID = -1;
+                this.tempSigID = reg.tempMethodSigCanonicalizer.register(nestedMethod);
+            }
+        }
         this.closures = closures !== null && closures !== void 0 ? closures : [];
     }
     getNestedMethod() {
-        return this.nestedMethodSignature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (this.nestedMethodSigID >= 0) {
+            return reg.methodSigCanonicalizer.get(this.nestedMethodSigID);
+        }
+        if (this.tempSigID !== undefined) {
+            const sig = reg.tempMethodSigCanonicalizer.get(this.tempSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+            // 惰性物化：已迁移 → 替换记录直达 formal（tempSigID 保留作痕迹）。
+            const formalId = reg.tempMethodSigCanonicalizer.getReplacement(this.tempSigID);
+            if (formalId !== -1) {
+                const formalSig = reg.methodSigCanonicalizer.get(formalId);
+                if (formalSig !== undefined) {
+                    this.nestedMethodSigID = formalId;
+                    return formalSig;
+                }
+            }
+        }
+        throw new Error('LexicalEnvType has no signature');
+    }
+    /** @internal Get the formal MethodSigID. */
+    getMethodSigID() {
+        return this.nestedMethodSigID;
+    }
+    /** @internal Get the temp sigID for the unresolved-signature registration. */
+    getTempSigID() {
+        return this.tempSigID;
     }
     getClosures() {
         return this.closures;
@@ -741,6 +1063,9 @@ class LexicalEnvType extends Type {
     addClosure(closure) {
         this.closures.push(closure);
     }
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
         return `[${this.getClosures().join(', ')}]`;
     }
@@ -749,17 +1074,63 @@ exports.LexicalEnvType = LexicalEnvType;
 class EnumValueType extends Type {
     constructor(signature, constant) {
         super();
-        this.signature = signature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (signature.isUnclear()) {
+            this.fieldSigID = -1;
+            this.tempSigID = reg.tempFieldSigCanonicalizer.register(signature);
+        }
+        else {
+            const existingId = reg.fieldSigCanonicalizer.getExistingId(signature);
+            if (existingId !== -1) {
+                this.fieldSigID = existingId;
+                this.tempSigID = undefined;
+            }
+            else {
+                logger.error(`EnumValueType: clear FieldSignature not interned — routing to temp defensively: ${signature.toString()}`);
+                this.fieldSigID = -1;
+                this.tempSigID = reg.tempFieldSigCanonicalizer.register(signature);
+            }
+        }
         this.constant = constant;
     }
     getFieldSignature() {
-        return this.signature;
+        const reg = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        if (this.fieldSigID >= 0) {
+            return reg.fieldSigCanonicalizer.get(this.fieldSigID);
+        }
+        if (this.tempSigID !== undefined) {
+            const sig = reg.tempFieldSigCanonicalizer.get(this.tempSigID);
+            if (sig !== undefined) {
+                return sig;
+            }
+            // 惰性物化：已迁移 → 替换记录直达 formal（tempSigID 保留作痕迹）。
+            const formalId = reg.tempFieldSigCanonicalizer.getReplacement(this.tempSigID);
+            if (formalId !== -1) {
+                const formalSig = reg.fieldSigCanonicalizer.get(formalId);
+                if (formalSig !== undefined) {
+                    this.fieldSigID = formalId;
+                    return formalSig;
+                }
+            }
+        }
+        throw new Error('EnumValueType has no signature');
+    }
+    /** @internal Get the formal FieldSigID. */
+    getFieldSigID() {
+        return this.fieldSigID;
+    }
+    /** @internal Get the temp sigID for the unresolved-signature registration. */
+    getTempSigID() {
+        return this.tempSigID;
     }
     getConstant() {
         return this.constant;
     }
+    isUnclearWithVisited(_visited) {
+        return false;
+    }
     getTypeString(_visited) {
-        return this.signature.toString();
+        return this.getFieldSignature().toString();
     }
 }
 exports.EnumValueType = EnumValueType;

package/lib/core/base/TypeExpr.d.ts

@@ -1,6 +1,6 @@
 import { Value } from './Value';
 import { ArkMethod } from '../model/ArkMethod';
-import { Type } from './Type';
+import { Type, UnclearVisited } from './Type';
 import { ArkBaseModel } from '../model/ArkBaseModel';
 /**
  * abstract type expr represents the type operations of types or values.
@@ -15,7 +15,7 @@ import { ArkBaseModel } from '../model/ArkBaseModel';
  *  ```
  */
 export declare abstract class AbstractTypeExpr extends Type {
-    abstract getUses(): Value[];
+    abstract getUses(acc?: Value[]): Value[];
     abstract getType(): Type;
     inferType(arkMethod: ArkMethod): void;
 }
@@ -38,8 +38,9 @@ export declare class TypeQueryExpr extends AbstractTypeExpr {
     getOpValue(): Value | ArkBaseModel;
     setGenerateTypes(types: Type[]): void;
     getGenerateTypes(): Type[] | undefined;
+    isUnclearWithVisited(visited: UnclearVisited): boolean;
     addGenericType(gType: Type): void;
-    getUses(): Value[];
+    getUses(acc?: Value[]): Value[];
     getType(): Type;
     getTypeString(): string;
     inferType(arkMethod: ArkMethod): void;
@@ -64,7 +65,8 @@ export declare class KeyofTypeExpr extends AbstractTypeExpr {
     constructor(opType: Type);
     getOpType(): Type;
     setOpType(opType: Type): void;
-    getUses(): Value[];
+    isUnclearWithVisited(visited: UnclearVisited): boolean;
+    getUses(acc?: Value[]): Value[];
     getType(): Type;
     getTypeString(): string;
     inferType(arkMethod: ArkMethod): void;

package/lib/core/base/TypeExpr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TypeExpr.d.ts","sourceRoot":"","sources":["../../../src/core/base/TypeExpr.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAoB,IAAI,EAA0B,MAAM,QAAQ,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAMrD;;;;;;;;;;;GAWG;AACH,8BAAsB,gBAAiB,SAAQ,IAAI;IAC/C,QAAQ,CAAC,OAAO,IAAI,KAAK,EAAE;IAE3B,QAAQ,CAAC,OAAO,IAAI,IAAI;IAEjB,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAG/C;AAED;;;;;;;;;;GAUG;AAEH,qBAAa,aAAc,SAAQ,gBAAgB;IAC/C,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,YAAY,CAAC,CAAS;gBAElB,OAAO,EAAE,KAAK,GAAG,YAAY,EAAE,aAAa,CAAC,EAAE,IAAI,EAAE;IAM1D,UAAU,CAAC,OAAO,EAAE,KAAK,GAAG,YAAY,GAAG,IAAI;IAI/C,UAAU,IAAI,KAAK,GAAG,YAAY;IAIlC,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAIrC,gBAAgB,IAAI,IAAI,EAAE,GAAG,SAAS;IAItC,cAAc,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IAOjC,OAAO,IAAI,KAAK,EAAE;IAWlB,OAAO,IAAI,IAAI;IAQf,aAAa,IAAI,MAAM;IAavB,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAG/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,aAAc,SAAQ,gBAAgB;IAC/C,OAAO,CAAC,MAAM,CAAO;gBAET,MAAM,EAAE,IAAI;IAKjB,SAAS,IAAI,IAAI;IAIjB,SAAS,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI;IAI7B,OAAO,IAAI,KAAK,EAAE;IAQlB,OAAO,IAAI,IAAI;IAIf,aAAa,IAAI,MAAM;IAOvB,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAG/C"}
+{"version":3,"file":"TypeExpr.d.ts","sourceRoot":"","sources":["../../../src/core/base/TypeExpr.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAoB,IAAI,EAAE,cAAc,EAA0B,MAAM,QAAQ,CAAC;AAExF,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAMrD;;;;;;;;;;;GAWG;AACH,8BAAsB,gBAAiB,SAAQ,IAAI;IAC/C,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE;IAExC,QAAQ,CAAC,OAAO,IAAI,IAAI;IAEjB,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAG/C;AAED;;;;;;;;;;GAUG;AAEH,qBAAa,aAAc,SAAQ,gBAAgB;IAC/C,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,YAAY,CAAC,CAAS;gBAElB,OAAO,EAAE,KAAK,GAAG,YAAY,EAAE,aAAa,CAAC,EAAE,IAAI,EAAE;IAM1D,UAAU,CAAC,OAAO,EAAE,KAAK,GAAG,YAAY,GAAG,IAAI;IAI/C,UAAU,IAAI,KAAK,GAAG,YAAY;IAIlC,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAIrC,gBAAgB,IAAI,IAAI,EAAE,GAAG,SAAS;IAItC,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO;IAoBtD,cAAc,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IAOjC,OAAO,CAAC,GAAG,GAAE,KAAK,EAAO,GAAG,KAAK,EAAE;IAUnC,OAAO,IAAI,IAAI;IAQf,aAAa,IAAI,MAAM;IAavB,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAG/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,aAAc,SAAQ,gBAAgB;IAC/C,OAAO,CAAC,MAAM,CAAO;gBAET,MAAM,EAAE,IAAI;IAKjB,SAAS,IAAI,IAAI;IAIjB,SAAS,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI;IAI7B,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO;IAQtD,OAAO,CAAC,GAAG,GAAE,KAAK,EAAO,GAAG,KAAK,EAAE;IAOnC,OAAO,IAAI,IAAI;IAIf,aAAa,IAAI,MAAM;IAOvB,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAG/C"}