arkanalyzer 1.0.85 → 1.0.87

package/lib/frontend/cppFrontend/common/ModelUtils.js

@@ -0,0 +1,567 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * 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.
+ */
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxxModelUtils = exports.setTs2CxxFuncMapOfClass = exports.shouldAddCxxHeaderImport = exports.findExportInfo = exports.getArkFile = void 0;
+const ArkFile_1 = require("../../../core/model/ArkFile");
+const ArkSignature_1 = require("../../../core/model/ArkSignature");
+const ArkExport_1 = require("../../../core/model/ArkExport");
+const logger_1 = __importStar(require("../../../utils/logger"));
+const FileUtils_1 = require("../../../utils/FileUtils");
+const path_1 = __importDefault(require("path"));
+const ArkImport_1 = require("../../../core/model/ArkImport");
+const ArkMethod_1 = require("../../../core/model/ArkMethod");
+const ArkClass_1 = require("../../../core/model/ArkClass");
+const Local_1 = require("../../../core/base/Local");
+const Constant_1 = require("../../../core/base/Constant");
+const Const_1 = require("../../../core/common/Const");
+const Type_1 = require("../../../core/base/Type");
+const ArkNamespace_1 = require("../../../core/model/ArkNamespace");
+const ModelUtils_1 = require("../../../core/common/ModelUtils");
+const TypeInference_1 = require("../../../core/common/TypeInference");
+const Type_2 = require("../base/Type");
+// Common C++standard library header files (excluding the .h suffix)
+const CXX_STD_HEADERS = new Set([
+    'iostream',
+    'iomanip',
+    'fstream',
+    'sstream',
+    'string',
+    'vector',
+    'map',
+    'unordered_map',
+    'set',
+    'unordered_set',
+    'queue',
+    'stack',
+    'list',
+    'algorithm',
+    'utility',
+    'memory',
+    'thread',
+    'mutex',
+    'condition_variable',
+    'future',
+    'atomic',
+    'chrono',
+    'functional',
+    'stdexcept',
+    'type_traits',
+    'cassert',
+    'cstdint',
+    'cstdlib',
+    'cstdio',
+    'cstring',
+    'cmath',
+    'array',
+    'bitset',
+    'deque',
+    'tuple',
+    'numeric',
+    'any',
+    'optional',
+    'variant',
+    'filesystem',
+    'span',
+]);
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ModelUtils');
+/**
+ * find arkFile by from info
+ * #include "xx/xx.h"
+ * @param im importInfo or exportInfo
+ */
+function getArkFile(im) {
+    let from = im.getFrom();
+    if (!from) {
+        return null;
+    }
+    if (!path_1.default.isAbsolute(from)) {
+        from = (0, FileUtils_1.getFileAbsPath)([im.getDeclaringArkFile().getFilePath()], from);
+    }
+    if (!from) {
+        return null;
+    }
+    const scene = im.getDeclaringArkFile().getScene();
+    return scene.getFile(new ArkSignature_1.FileSignature(scene.getProjectName(), path_1.default.relative(scene.getRealProjectDir(), from)));
+}
+exports.getArkFile = getArkFile;
+/**
+ * #include "xx/xx.h" ==> Precompilation directly expands ==> Equivalent to importing all content of the file ==> Get exportInfo directly from header file
+ * find from info's export
+ * @param fromInfo importInfo or exportInfo
+ * @param fromFile The file where the imported object is located
+ */
+function findExportInfo(fromInfo, fromFile) {
+    var _a, _b;
+    // scenario 1. processing using namespace xxx
+    if (fromInfo instanceof ArkImport_1.ImportInfo && fromInfo.getImportType() === 'NamespaceImport' && fromInfo.getFrom() === '') {
+        return processNamespaceImport(fromInfo);
+    }
+    // scenario 2. processing #include "xx.h"
+    let file = fromFile !== null && fromFile !== void 0 ? fromFile : getArkFile(fromInfo);
+    if (!file) {
+        logger.warn(`${fromInfo.getOriginName()} ${fromInfo.getFrom()} file not found: ${(_b = (_a = fromInfo.getDeclaringArkFile()) === null || _a === void 0 ? void 0 : _a.getFileSignature()) === null || _b === void 0 ? void 0 : _b.toString()}`);
+        return null;
+    }
+    if (fromInfo instanceof ArkImport_1.ImportInfo && fromInfo.getImportClauseName().startsWith('#include')) {
+        return processIncludeRef(fromInfo, file);
+    }
+    return processHeaderExportInfos(fromInfo, file);
+}
+exports.findExportInfo = findExportInfo;
+function shouldAddCxxHeaderImport(element) {
+    if (!Object.prototype.hasOwnProperty.call(element, 'importClauseName')) {
+        return false;
+    }
+    return isValidCxxHeaderPath(element.getImportClauseName());
+}
+exports.shouldAddCxxHeaderImport = shouldAddCxxHeaderImport;
+function processNamespaceImport(fromInfo) {
+    var _a, _b;
+    const declFile = fromInfo.getDeclaringArkFile();
+    const namespaceName = fromInfo.getImportClauseName();
+    // namespace is from current file or importInfo
+    let lazyExportInfo = (_a = declFile.getExportInfoBy(namespaceName)) !== null && _a !== void 0 ? _a : (_b = declFile.getImportInfoBy(namespaceName)) === null || _b === void 0 ? void 0 : _b.getExportInfo();
+    if (lazyExportInfo) {
+        let arkExport = lazyExportInfo.getArkExport() || null;
+        lazyExportInfo.setArkExport(arkExport);
+        if (!arkExport) {
+            return lazyExportInfo;
+        }
+        lazyExportInfo.setExportClauseType(ArkExport_1.ExportType.NAME_SPACE);
+        // If the namespace is imported in a header file, it is necessary to construct the  exportInfo for the imported namespace.
+        if (isValidCxxHeaderPath(declFile.getFilePath())) {
+            const namespaceExportInfo = new ArkExport_1.ExportInfo.Builder()
+                .exportClauseType(ArkExport_1.ExportType.NAME_SPACE)
+                .exportClauseName(namespaceName)
+                .declaringArkFile(declFile)
+                .arkExport(arkExport)
+                .build();
+            declFile.addExportInfo(namespaceExportInfo);
+        }
+        return lazyExportInfo;
+    }
+    return null;
+}
+function isValidCxxHeaderPath(headerPath) {
+    if (!headerPath) {
+        return false;
+    }
+    const normalized = headerPath.replace(/\\/g, '/').toLowerCase();
+    // Check the sdk/default path
+    if (normalized.includes('sdk/default')) {
+        return false;
+    }
+    // Split the path and check the last file name
+    const parts = normalized.split('/');
+    let filename = parts.length > 0 ? parts[parts.length - 1] : '';
+    filename = filename.replace('"', '');
+    // Determine whether it is a standard library name or a standard library name+ h
+    if (CXX_STD_HEADERS.has(filename) || (filename.endsWith('.h') && CXX_STD_HEADERS.has(filename.replace(/\.h$/, '')))) {
+        return false;
+    }
+    return true;
+}
+/* Handling header file references for # include "xx/xx. h" */
+function processIncludeRef(fromInfo, headerFile) {
+    var _a, _b;
+    // 1.Construct # include "xxx/xx" The exportInfo referenced by the header file is the DefaultClass of the header file
+    const includeExportInfo = new ArkExport_1.ExportInfo.Builder()
+        .exportClauseType(ArkExport_1.ExportType.CLASS)
+        .exportClauseName(`#include "${fromInfo.getFrom()}"`)
+        .declaringArkFile(headerFile)
+        .arkExport(headerFile.getDefaultClass())
+        .build();
+    // 2.Add the exportInfo of the header file to the importInfoMaps of the current file, and set lazyImportInfo
+    const declFile = fromInfo.getDeclaringArkFile();
+    let includeClauseName = fromInfo.getImportClauseName();
+    for (const exportInfo of headerFile.getExportInfos()) {
+        let headerRealIm = new ArkImport_1.ImportInfo();
+        // if there is "using namespace xxx" in declFile or the indirectly referenced file, we should keep the original import type
+        const curClauseName = exportInfo.getExportClauseName();
+        let importType;
+        if (((_a = declFile.getImportInfoBy(curClauseName)) === null || _a === void 0 ? void 0 : _a.getImportType()) === 'NamespaceImport' ||
+            ((_b = headerFile.getImportInfoBy(curClauseName)) === null || _b === void 0 ? void 0 : _b.getImportType()) === 'NamespaceImport') {
+            importType = 'NamespaceImport';
+        }
+        else {
+            importType = 'NamedImports';
+        }
+        headerRealIm.build(curClauseName, importType, headerFile.getFilePath(), exportInfo.getOriginTsPosition(), 0);
+        headerRealIm.setTsSourceCode(includeClauseName);
+        headerRealIm.setDeclaringArkFile(declFile);
+        if (shouldAddCxxHeaderImport(headerRealIm)) {
+            declFile.addImportInfo(headerRealIm);
+        }
+        headerRealIm.getLazyExportInfo(); // The findExportInfo function will be recursed
+    }
+    // 3.Add the importInfos of the header file to the importInfoMaps of the current file, and set lazyImportInfo
+    for (const im of headerFile.getImportInfos()) {
+        if (declFile.getImportInfoBy(im.getImportClauseName())) {
+            continue;
+        }
+        if (shouldAddCxxHeaderImport(im)) {
+            declFile.addImportInfo(im);
+        }
+        im.getLazyExportInfo();
+    }
+    return includeExportInfo;
+}
+/* Process the exportInfo of the header file (as the current file named importInfo) */
+function processHeaderExportInfos(fromInfo, headerFile) {
+    const exportName = fromInfo.getOriginName();
+    let exportInfo = headerFile.getExportInfoBy(exportName);
+    if (!exportInfo) {
+        return null;
+    }
+    let arkExport = exportInfo.getArkExport() || null;
+    exportInfo.setArkExport(arkExport);
+    if (arkExport) {
+        exportInfo.setExportClauseType(arkExport.getExportType());
+    }
+    return exportInfo;
+}
+/**
+ * Record the mapping relationship between cpp functions and ts functions (when there are napi_property_descriptor and napi_define_class identifiers)
+ * @param elementValues Value of each actual parameter of the function describing the mapping relationship
+ * @param isDefineClass Whether it is a napi_define_class identifier
+ * @param declMethod The ArkMethod where the call is located
+ * @return None
+ */
+function setTs2CxxFuncMapOfClass(elementValues, isDefineClass, declMethod) {
+    const curArkClass = declMethod.getDeclaringArkClass();
+    const dfltArkClass = declMethod.getDeclaringArkFile().getDefaultClass();
+    if (!(curArkClass && dfltArkClass)) {
+        return;
+    }
+    let funcElements;
+    let tsFuncNameIdx;
+    if (isDefineClass) {
+        // napi_define_class sets the constructor of the externally exposed class
+        funcElements = elementValues.length > 4 ? [elementValues[3]] : [];
+        tsFuncNameIdx = 1;
+    }
+    else {
+        // Fields set by functions in napi_property_descriptor
+        funcElements = elementValues.length > 5 ? elementValues.slice(2, 5) : [];
+        tsFuncNameIdx = 0;
+    }
+    const cxxFunc = findMatchingCxxMethod(funcElements, declMethod);
+    if (elementValues[tsFuncNameIdx] instanceof Constant_1.StringConstant) {
+        dfltArkClass.addTs2cxxFuncMapElement(elementValues[tsFuncNameIdx].getValue(), cxxFunc);
+    }
+}
+exports.setTs2CxxFuncMapOfClass = setTs2CxxFuncMapOfClass;
+/**
+ * Find the actual cpp function corresponding to the function pointer in the mapping function
+ * @param funcElements Value array corresponding to function pointers
+ * @param declMethod The ArkMethod where the call is located
+ * @return Returns the found matching function array
+ */
+function findMatchingCxxMethod(funcElements, declMethod) {
+    var _a;
+    const cxxFunc = [];
+    const currArkClass = declMethod.getDeclaringArkClass();
+    const classesToBeSearched = [];
+    classesToBeSearched.push(currArkClass, ...getIncludeDefaultClasses(declMethod));
+    const scene = currArkClass.getDeclaringArkFile().getScene();
+    for (const element of funcElements) {
+        if (!(element instanceof Local_1.Local)) {
+            continue;
+        }
+        let funcRef = element;
+        const mtdName = funcRef.getName();
+        // If it is local and in %num format => %num = A.b, it should actually be a member of a class
+        if (mtdName.startsWith(Const_1.TEMP_LOCAL_PREFIX)) {
+            const realType = funcRef.getType();
+            if (!(realType instanceof Type_1.FunctionType)) {
+                continue;
+            }
+            let matchMtd = scene.getMethod(realType.getMethodSignature());
+            if (matchMtd) {
+                matchMtd = getFuncImplement(matchMtd);
+                cxxFunc.push(matchMtd);
+            }
+            continue;
+        }
+        // If it is local and does not start with "%" => Member function of current class or global function
+        for (const cls of classesToBeSearched) {
+            let matchMtd = (_a = cls.getMethodWithName(mtdName)) !== null && _a !== void 0 ? _a : cls.getStaticMethodWithName(mtdName);
+            if (matchMtd) {
+                matchMtd = getFuncImplement(matchMtd);
+                cxxFunc.push(matchMtd);
+            }
+        }
+    }
+    return cxxFunc;
+}
+/**
+ * Get the defaultClass of the include header files of the file to which the current arkInstance belongs
+ * @param arkInstance Instance of ArkIR
+ * @return Returns all qualified defaultClasses obtained
+ */
+function getIncludeDefaultClasses(arkInstance) {
+    const defaultClasses = [];
+    if (arkInstance instanceof ArkMethod_1.ArkMethod || arkInstance instanceof ArkClass_1.ArkClass) {
+        arkInstance = arkInstance.getDeclaringArkFile();
+    }
+    const includeFiles = [];
+    for (const info of arkInstance.getImportInfos()) {
+        const imFrom = info.getFrom();
+        if (!imFrom) {
+            continue;
+        }
+        includeFiles.push(imFrom);
+    }
+    if (includeFiles.length === 0) {
+        return defaultClasses;
+    }
+    const scene = arkInstance.getScene();
+    scene.getFiles().forEach(file => {
+        if (file.getLanguage() !== ArkFile_1.Language.CXX || !includeFiles.includes(file.getFilePath())) {
+            return;
+        }
+        defaultClasses.push(file.getDefaultClass());
+    });
+    return defaultClasses;
+}
+function getFuncImplement(mtd) {
+    if (mtd.isDefaultArkMethod() || mtd.getName() === Const_1.INSTANCE_INIT_METHOD_NAME || mtd.getName() === Const_1.STATIC_INIT_METHOD_NAME) {
+        return mtd;
+    }
+    const realImplSignature = mtd.getImplementationSignature();
+    if (!realImplSignature) {
+        return mtd;
+    }
+    const realImplMtd = mtd.getDeclaringArkFile().getScene().getMethod(realImplSignature);
+    if (!realImplMtd || !realImplMtd.getImplementationSignature()) {
+        return mtd;
+    }
+    return realImplMtd;
+}
+class CxxModelUtils {
+    static getArkExportInImportInfoWithName(name, arkFile, arkClass) {
+        var _a, _b, _c;
+        let arkExport = (_b = (_a = arkFile.getImportInfoBy(name)) === null || _a === void 0 ? void 0 : _a.getLazyExportInfo()) === null || _b === void 0 ? void 0 : _b.getArkExport();
+        if (arkExport) {
+            return arkExport;
+        }
+        let declNamespace;
+        if (arkClass) {
+            declNamespace = arkClass.getDeclaringArkNamespace();
+        }
+        // if using namespace or use type in same name namespace in file，we can call the method or class in the namespace without a prefix.
+        for (const im of arkFile.getImportInfos()) {
+            const imArkExport = (_c = im.getLazyExportInfo()) === null || _c === void 0 ? void 0 : _c.getArkExport();
+            if (!(imArkExport instanceof ArkNamespace_1.ArkNamespace)) {
+                continue;
+            }
+            const imNS = imArkExport;
+            // using namespace xxx
+            if (im.getImportType() === 'NamespaceImport') {
+                arkExport = CxxModelUtils.findPropertyInNamespace(name, imNS);
+                if (arkExport) {
+                    return arkExport;
+                }
+            }
+            // infer type within the same namespace across different files
+            if ((declNamespace === null || declNamespace === void 0 ? void 0 : declNamespace.getName()) !== imNS.getName()) {
+                continue;
+            }
+            arkExport = CxxModelUtils.findPropertyInNamespace(name, imNS);
+            if (arkExport) {
+                return arkExport;
+            }
+        }
+        return null;
+    }
+    static findPropertyInClass(name, arkClass) {
+        var _a, _b, _c, _d, _e;
+        let property = (_d = (_c = (_b = (_a = arkClass.getMethodWithName(name)) !== null && _a !== void 0 ? _a : arkClass.getStaticMethodWithName(name)) !== null && _b !== void 0 ? _b : arkClass.getMethodWithName('Get-' + name)) !== null && _c !== void 0 ? _c : arkClass.getFieldWithName(name)) !== null && _d !== void 0 ? _d : arkClass.getStaticFieldWithName(name);
+        if (property) {
+            return property;
+        }
+        if (arkClass.isDefaultArkClass()) {
+            return (0, ModelUtils_1.findArkExport)(arkClass.getDeclaringArkFile().getExportInfoBy(name));
+        }
+        // In cases where a class's declaration and definition are separated, we may consider searching for the property at the class declaration.
+        const clsDeclareSignature = arkClass.getDeclareSignature();
+        let declClass;
+        if (clsDeclareSignature) {
+            declClass = (_e = arkClass.getDeclaringArkFile().getScene().getFile(clsDeclareSignature.getDeclaringFileSignature())) === null || _e === void 0 ? void 0 : _e.getClass(clsDeclareSignature);
+        }
+        const heritageClasses = arkClass.getAllHeritageClasses();
+        if (declClass) {
+            property = this.findPropertyInClass(name, declClass);
+            if (property) {
+                return property;
+            }
+            heritageClasses.push(...declClass.getAllHeritageClasses());
+        }
+        for (const heritage of heritageClasses) {
+            property = this.findPropertyInClass(name, heritage);
+            if (property) {
+                return property;
+            }
+        }
+        const objectClass = arkClass.getDeclaringArkFile().getScene().getSdkGlobal('Object');
+        if (objectClass instanceof ArkClass_1.ArkClass && arkClass !== objectClass) {
+            return this.findPropertyInClass(name, objectClass);
+        }
+        return null;
+    }
+    static getClassFromAnonymousNamespaceByName(className, declFile) {
+        const anonyNamespaces = declFile.getNamespaces().filter(ns => ns.getName().startsWith(Const_1.ANONYMOUS_NAMESPACE_PREFIX));
+        for (const anonyNamespace of anonyNamespaces) {
+            const matchedClass = anonyNamespace.getClassWithName(className);
+            if (matchedClass) {
+                return matchedClass;
+            }
+        }
+        return null;
+    }
+    static getStaticMethodWithName(methodName, thisClass) {
+        const thisNamespace = thisClass.getDeclaringArkNamespace();
+        if (thisNamespace) {
+            const defaultClass = thisNamespace.getClassWithName(Const_1.DEFAULT_ARK_CLASS_NAME);
+            if (defaultClass) {
+                const method = defaultClass.getMethodWithName(methodName);
+                if (method) {
+                    return method;
+                }
+            }
+        }
+        return this.getStaticMethodInFileWithName(methodName, thisClass.getDeclaringArkFile());
+    }
+    static getStaticMethodInFileWithName(methodName, arkFile) {
+        const anonymousNamespaces = this.getAccessibleAnonNamespacesInFile(arkFile);
+        const allDefaultClasses = [];
+        allDefaultClasses.push(arkFile.getDefaultClass());
+        anonymousNamespaces.forEach(ns => {
+            allDefaultClasses.push(ns.getDefaultClass());
+        });
+        for (const defaultClass of allDefaultClasses) {
+            let method = defaultClass.getMethodWithName(methodName);
+            if (method) {
+                return method;
+            }
+        }
+        return null;
+    }
+    static getAccessibleAnonNamespacesInFile(file, namespace) {
+        const anonymousNamespaces = [];
+        const traversableNamespace = namespace ? namespace.getNamespaces() : file.getNamespaces();
+        for (const ns of traversableNamespace) {
+            if (ns.getName().startsWith(Const_1.ANONYMOUS_NAMESPACE_PREFIX)) {
+                anonymousNamespaces.push(ns);
+                anonymousNamespaces.push(...this.getAccessibleAnonNamespacesInFile(file, ns));
+            }
+        }
+        return anonymousNamespaces;
+    }
+    static findPropertyInNamespace(name, namespace) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const allAccessibleNamespaces = [namespace];
+        allAccessibleNamespaces.push(...this.getAccessibleAnonNamespacesInFile(namespace.getDeclaringArkFile(), namespace));
+        for (const ns of allAccessibleNamespaces) {
+            const property = (_j = (_e = (_d = (_c = (_b = (_a = ns.getDefaultClass()) === null || _a === void 0 ? void 0 : _a.getMethodWithName(name)) !== null && _b !== void 0 ? _b : (0, ModelUtils_1.findArkExport)(ns.getExportInfoBy(name))) !== null && _c !== void 0 ? _c : ns.getClassWithName(name)) !== null && _d !== void 0 ? _d : ns.getNamespaceWithName(name)) !== null && _e !== void 0 ? _e : (_h = (_g = (_f = ns.getDefaultClass()) === null || _f === void 0 ? void 0 : _f.getDefaultArkMethod()) === null || _g === void 0 ? void 0 : _g.getBody()) === null || _h === void 0 ? void 0 : _h.getAliasTypeByName(name)) !== null && _j !== void 0 ? _j : (_o = (_m = (_l = (_k = ns.getDefaultClass()) === null || _k === void 0 ? void 0 : _k.getDefaultArkMethod()) === null || _l === void 0 ? void 0 : _l.getBody()) === null || _m === void 0 ? void 0 : _m.getLocals()) === null || _o === void 0 ? void 0 : _o.get(name);
+            if (property) {
+                return property;
+            }
+        }
+        return undefined;
+    }
+    static findSymbolInFileWithName(symbolName, arkClass, onlyType = false) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        // find symbol from enum value
+        if (arkClass.getCategory() === ArkClass_1.ClassCategory.ENUM) {
+            const field = arkClass.getStaticFieldWithName(symbolName);
+            if (field) {
+                return new Local_1.Local(symbolName, (_a = TypeInference_1.TypeInference.getEnumValueType(field)) !== null && _a !== void 0 ? _a : field.getType());
+            }
+        }
+        // look up symbol from inner to outer
+        let currNamespace = arkClass.getDeclaringArkNamespace();
+        let result;
+        while (currNamespace) {
+            result = this.findPropertyInNamespace(symbolName, currNamespace);
+            if (result) {
+                return result;
+            }
+            currNamespace = currNamespace.getDeclaringArkNamespace();
+        }
+        const file = arkClass.getDeclaringArkFile();
+        result =
+            (_e = (_b = file.getClassWithName(symbolName)) !== null && _b !== void 0 ? _b : (_d = (_c = file.getDefaultClass().getDefaultArkMethod()) === null || _c === void 0 ? void 0 : _c.getBody()) === null || _d === void 0 ? void 0 : _d.getAliasTypeByName(symbolName)) !== null && _e !== void 0 ? _e : (_h = (_g = (_f = file.getDefaultClass()) === null || _f === void 0 ? void 0 : _f.getDefaultArkMethod()) === null || _g === void 0 ? void 0 : _g.getBody()) === null || _h === void 0 ? void 0 : _h.getLocals().get(symbolName);
+        if (!result && !onlyType) {
+            result = (_j = file.getNamespaceWithName(symbolName)) !== null && _j !== void 0 ? _j : file.getDefaultClass().getMethodWithName(symbolName);
+        }
+        if (result) {
+            return result;
+        }
+        const allAnonyNamespaces = this.getAccessibleAnonNamespacesInFile(file);
+        for (const ns of allAnonyNamespaces) {
+            result = this.findPropertyInNamespace(symbolName, ns);
+            if (result) {
+                return result;
+            }
+        }
+        return null;
+    }
+    static isIOStreamObjectMatched(parameters, args, scene) {
+        // Compare the output object directly, i.e., the last param/arg
+        const lastParam = parameters.length > 0 ? parameters[parameters.length - 1] : null;
+        const lastArg = args.length > 0 ? args[args.length - 1] : null;
+        if (!lastParam || !lastArg) {
+            return false;
+        }
+        let lastParamType = lastParam.getType();
+        let lastArgType = lastArg.getType();
+        if (lastParamType instanceof Type_2.ReferenceType) {
+            lastParamType = lastParamType.getBaseType();
+        }
+        if (lastArgType instanceof Type_2.ReferenceType) {
+            lastArgType = lastArgType.getBaseType();
+        }
+        return ModelUtils_1.ModelUtils.matchType(lastParamType, lastArgType, lastArg, scene);
+    }
+}
+exports.CxxModelUtils = CxxModelUtils;