@tslite/checker 1.8.0 → 1.12.0

package/dist/symbolWalker.js

@@ -0,0 +1,167 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/symbolWalker.ts: o namespace virou módulo ES, com os imports explícitos.
+// O walker percorre os tipos e os símbolos que um tipo alcança; quem o pede é o refactor que extrai um trecho, para achar
+// os parâmetros de tipo que o trecho usa (CK-60, CK-67). Saem dele o `thisType` de uma interface (o `this`, CK-02), as
+// construct signatures de um tipo e a flag de classe (CK-02). Os parâmetros do `getBaseTypes` e do `getResolvedSymbol`
+// têm o tipo que o TypeScript 5 deu a eles (o §5 do `docs/ARCHITECTURE.md`).
+import { SyntaxKind, clear, forEach, getOwnValues, getSymbolId, } from "./_namespaces/ts.js";
+export function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getIndexTypeOfStructuredType, getConstraintOfTypeParameter, getFirstIdentifier, getTypeArguments) {
+    return getSymbolWalker;
+    function getSymbolWalker(accept = () => true) {
+        const visitedTypes = []; // Sparse array from id to type
+        const visitedSymbols = []; // Sparse array from id to symbol
+        return {
+            walkType: type => {
+                try {
+                    visitType(type);
+                    return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
+                }
+                finally {
+                    clear(visitedTypes);
+                    clear(visitedSymbols);
+                }
+            },
+            walkSymbol: symbol => {
+                try {
+                    visitSymbol(symbol);
+                    return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
+                }
+                finally {
+                    clear(visitedTypes);
+                    clear(visitedSymbols);
+                }
+            },
+        };
+        function visitType(type) {
+            if (!type) {
+                return;
+            }
+            if (visitedTypes[type.id]) {
+                return;
+            }
+            visitedTypes[type.id] = type;
+            // Reuse visitSymbol to visit the type's symbol,
+            //  but be sure to bail on recuring into the type if accept declines the symbol.
+            const shouldBail = visitSymbol(type.symbol);
+            if (shouldBail)
+                return;
+            // Visit the type's related types, if any
+            if (type.flags & 524288 /* TypeFlags.Object */) {
+                const objectType = type;
+                const objectFlags = objectType.objectFlags;
+                if (objectFlags & 4 /* ObjectFlags.Reference */) {
+                    visitTypeReference(type);
+                }
+                if (objectFlags & 32 /* ObjectFlags.Mapped */) {
+                    visitMappedType(type);
+                }
+                // Na tag, também a classe (CK-02).
+                if (objectFlags & 2 /* ObjectFlags.Interface */) {
+                    visitInterfaceType(type);
+                }
+                if (objectFlags & (8 /* ObjectFlags.Tuple */ | 16 /* ObjectFlags.Anonymous */)) {
+                    visitObjectType(objectType);
+                }
+            }
+            if (type.flags & 262144 /* TypeFlags.TypeParameter */) {
+                visitTypeParameter(type);
+            }
+            if (type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) {
+                visitUnionOrIntersectionType(type);
+            }
+            if (type.flags & 4194304 /* TypeFlags.Index */) {
+                visitIndexType(type);
+            }
+            if (type.flags & 8388608 /* TypeFlags.IndexedAccess */) {
+                visitIndexedAccessType(type);
+            }
+        }
+        function visitTypeReference(type) {
+            visitType(type.target);
+            forEach(getTypeArguments(type), visitType);
+        }
+        function visitTypeParameter(type) {
+            visitType(getConstraintOfTypeParameter(type));
+        }
+        function visitUnionOrIntersectionType(type) {
+            forEach(type.types, visitType);
+        }
+        function visitIndexType(type) {
+            visitType(type.type);
+        }
+        function visitIndexedAccessType(type) {
+            visitType(type.objectType);
+            visitType(type.indexType);
+            visitType(type.constraint);
+        }
+        function visitMappedType(type) {
+            visitType(type.typeParameter);
+            visitType(type.constraintType);
+            visitType(type.templateType);
+            visitType(type.modifiersType);
+        }
+        function visitSignature(signature) {
+            const typePredicate = getTypePredicateOfSignature(signature);
+            if (typePredicate) {
+                visitType(typePredicate.type);
+            }
+            forEach(signature.typeParameters, visitType);
+            for (const parameter of signature.parameters) {
+                visitSymbol(parameter);
+            }
+            visitType(getRestTypeOfSignature(signature));
+            visitType(getReturnTypeOfSignature(signature));
+        }
+        // Na tag, também o tipo `this` da interface (CK-02). A interface que fica é a de um embutido, que nasce com as
+        // bases resolvidas (CK-48), ou o alvo de uma tupla.
+        function visitInterfaceType(interfaceT) {
+            visitObjectType(interfaceT);
+            forEach(interfaceT.typeParameters, visitType);
+            forEach(getBaseTypes(interfaceT), visitType);
+        }
+        // Na tag, também as construct signatures (CK-02).
+        function visitObjectType(type) {
+            const stringIndexType = getIndexTypeOfStructuredType(type, 0 /* IndexKind.String */);
+            visitType(stringIndexType);
+            const numberIndexType = getIndexTypeOfStructuredType(type, 1 /* IndexKind.Number */);
+            visitType(numberIndexType);
+            // The two checks above *should* have already resolved the type (if needed), so this should be cached
+            const resolved = resolveStructuredTypeMembers(type);
+            for (const signature of resolved.callSignatures) {
+                visitSignature(signature);
+            }
+            for (const p of resolved.properties) {
+                visitSymbol(p);
+            }
+        }
+        function visitSymbol(symbol) {
+            if (!symbol) {
+                return false;
+            }
+            const symbolId = getSymbolId(symbol);
+            if (visitedSymbols[symbolId]) {
+                return false;
+            }
+            visitedSymbols[symbolId] = symbol;
+            if (!accept(symbol)) {
+                return true;
+            }
+            const t = getTypeOfSymbol(symbol);
+            visitType(t); // Should handle members on classes and such
+            if (symbol.exports) {
+                symbol.exports.forEach(visitSymbol);
+            }
+            forEach(symbol.declarations, d => {
+                // Type queries are too far resolved when we just visit the symbol's type
+                //  (their type resolved directly to the member deeply referenced)
+                // So to get the intervening symbols, we need to check if there's a type
+                // query node on any of the symbol's declarations and get symbols there
+                if (d.type && d.type.kind === SyntaxKind.TypeQuery) {
+                    const query = d.type;
+                    const entity = getResolvedSymbol(getFirstIdentifier(query.exprName));
+                    visitSymbol(entity);
+                }
+            });
+            return false;
+        }
+    }
+}