tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-evaluator.js

@@ -0,0 +1,188 @@
+// Constant evaluation of enum member initializers and template expressions.
+import { getExpression, getInitializer, getText, getType, getName, } from './ast.js';
+import { computeEnumMemberValues } from './checker-declared-types.js';
+import { getGlobalSymbol, resolveEntityName } from './checker-symbols.js';
+import { declarationNameToString, getSourceFileOfNode } from './binder-utilities.js';
+import { isConstantVariable } from './checker-narrowing.js';
+import { isBlockScopedNameDeclaredBeforeUse } from './checker-declaration-order.js';
+export class EvaluatorResult {
+    kind = 0 /* EvaluatedKind.None */;
+    numberValue = 0;
+    stringValue = '';
+    flags = 0 /* EvaluatedFlags.None */;
+    static number(value) {
+        const r = new EvaluatorResult();
+        r.kind = 1 /* EvaluatedKind.Number */;
+        r.numberValue = value;
+        return r;
+    }
+    static string(value) {
+        const r = new EvaluatorResult();
+        r.kind = 2 /* EvaluatedKind.String */;
+        r.stringValue = value;
+        return r;
+    }
+}
+/** No constant value. */
+function none() {
+    return new EvaluatorResult();
+}
+function withFlags(result, flags) {
+    result.flags = flags;
+    return result;
+}
+/** The constant value of an enum member initializer, if it has one. */
+export function evaluateEnumMember(c, expr, member) {
+    return evaluate(c, expr, member);
+}
+/** The constant value of `expr`, evaluated at `location`. */
+export function evaluate(c, expr, location) {
+    switch (expr.kind) {
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const operand = evaluate(c, expr.operand, location);
+            if (operand.kind !== 1 /* EvaluatedKind.Number */)
+                return none();
+            const v = operand.numberValue;
+            const flags = operand.flags & 2 /* EvaluatedFlags.ResolvedOtherFiles */;
+            switch (expr.operator) {
+                case 39 /* SyntaxKind.PlusToken */:
+                    return withFlags(EvaluatorResult.number(v), flags);
+                case 40 /* SyntaxKind.MinusToken */:
+                    return withFlags(EvaluatorResult.number(-v), flags);
+                case 54 /* SyntaxKind.TildeToken */:
+                    return withFlags(EvaluatorResult.number(~v), flags);
+            }
+            return none();
+        }
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const shape = expr;
+            const left = evaluate(c, shape.left, location);
+            const right = evaluate(c, shape.right, location);
+            const op = shape.operatorToken.kind;
+            const flags = ((left.flags | right.flags) & 2 /* EvaluatedFlags.ResolvedOtherFiles */) |
+                (op === 39 /* SyntaxKind.PlusToken */ ? (left.flags | right.flags) & 1 /* EvaluatedFlags.SyntacticallyString */ : 0);
+            if (left.kind === 1 /* EvaluatedKind.Number */ && right.kind === 1 /* EvaluatedKind.Number */) {
+                const l = left.numberValue;
+                const r = right.numberValue;
+                switch (op) {
+                    case 51 /* SyntaxKind.BarToken */:
+                        return withFlags(EvaluatorResult.number(l | r), flags);
+                    case 50 /* SyntaxKind.AmpersandToken */:
+                        return withFlags(EvaluatorResult.number(l & r), flags);
+                    case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+                        return withFlags(EvaluatorResult.number(l >> r), flags);
+                    case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+                        return withFlags(EvaluatorResult.number(l >>> r), flags);
+                    case 47 /* SyntaxKind.LessThanLessThanToken */:
+                        return withFlags(EvaluatorResult.number(l << r), flags);
+                    case 52 /* SyntaxKind.CaretToken */:
+                        return withFlags(EvaluatorResult.number(l ^ r), flags);
+                    case 41 /* SyntaxKind.AsteriskToken */:
+                        return withFlags(EvaluatorResult.number(l * r), flags);
+                    case 43 /* SyntaxKind.SlashToken */:
+                        return withFlags(EvaluatorResult.number(l / r), flags);
+                    case 39 /* SyntaxKind.PlusToken */:
+                        return withFlags(EvaluatorResult.number(l + r), flags);
+                    case 40 /* SyntaxKind.MinusToken */:
+                        return withFlags(EvaluatorResult.number(l - r), flags);
+                    case 44 /* SyntaxKind.PercentToken */:
+                        return withFlags(EvaluatorResult.number(l % r), flags);
+                    case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+                        return withFlags(EvaluatorResult.number(l ** r), flags);
+                }
+                return none();
+            }
+            if (op === 39 /* SyntaxKind.PlusToken */ &&
+                left.kind !== 0 /* EvaluatedKind.None */ &&
+                right.kind !== 0 /* EvaluatedKind.None */ &&
+                (left.kind === 2 /* EvaluatedKind.String */ || right.kind === 2 /* EvaluatedKind.String */))
+                return withFlags(EvaluatorResult.string(valueText(left) + valueText(right)), flags);
+            return none();
+        }
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return withFlags(EvaluatorResult.string(getText(expr)), 1 /* EvaluatedFlags.SyntacticallyString */);
+        case 229 /* SyntaxKind.TemplateExpression */: {
+            const shape = expr;
+            let text = getText(shape.head);
+            let flags = 1 /* EvaluatedFlags.SyntacticallyString */;
+            for (const span of shape.templateSpans.nodes) {
+                const s = span;
+                const value = evaluate(c, s.expression, location);
+                if (value.kind === 0 /* EvaluatedKind.None */)
+                    return none();
+                text += valueText(value) + getText(s.literal);
+                flags |= value.flags & 2 /* EvaluatedFlags.ResolvedOtherFiles */;
+            }
+            return withFlags(EvaluatorResult.string(text), flags);
+        }
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return EvaluatorResult.number(Number(getText(expr)));
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return evaluate(c, getExpression(expr), location);
+        case 79 /* SyntaxKind.Identifier */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+            const symbol = resolveEntityName(c, expr, 111551 /* SymbolFlags.Value */, true, false, undefined);
+            if (symbol === undefined)
+                return none();
+            if (expr.kind === 79 /* SyntaxKind.Identifier */) {
+                const text = getText(expr);
+                if ((text === 'Infinity' || text === 'NaN') &&
+                    symbol === getGlobalSymbol(c, text, 111551 /* SymbolFlags.Value */, undefined))
+                    return EvaluatorResult.number(Number(text));
+            }
+            if ((symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+                return evaluateEnumMemberReference(c, expr, symbol.valueDeclaration, location);
+            // Constants without annotations evaluate to their initializers, when declared before the use.
+            const declaration = symbol.valueDeclaration;
+            if (isConstantVariable(c, symbol) &&
+                declaration !== undefined &&
+                declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+                getType(declaration) === undefined &&
+                getInitializer(declaration) !== undefined &&
+                declaration !== location &&
+                isBlockScopedNameDeclaredBeforeUse(c, declaration, location)) {
+                const result = evaluate(c, getInitializer(declaration), declaration);
+                // A transpiler sees only this file, so a constant from another file is not written as a string here.
+                if (getSourceFileOfNode(location) !== getSourceFileOfNode(declaration))
+                    result.flags = 2 /* EvaluatedFlags.ResolvedOtherFiles */;
+                return result;
+            }
+            return none();
+        }
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            const root = getExpression(expr);
+            const argument = expr.argumentExpression;
+            if (argument.kind !== 10 /* SyntaxKind.StringLiteral */ && argument.kind !== 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */)
+                return none();
+            const rootSymbol = resolveEntityName(c, root, 111551 /* SymbolFlags.Value */, true, false, undefined);
+            if (rootSymbol === undefined || (rootSymbol.flags & 384 /* SymbolFlags.Enum */) === 0)
+                return none();
+            const member = rootSymbol.exports?.get(getText(argument));
+            return member !== undefined ? evaluateEnumMemberReference(c, expr, member.valueDeclaration, location) : none();
+        }
+    }
+    return none();
+}
+function evaluateEnumMemberReference(c, expr, declaration, location) {
+    if (declaration === undefined || declaration === location) {
+        const name = declaration !== undefined ? getName(declaration) : undefined;
+        c.error(expr, 719 /* Diagnostics.Property_0_is_used_before_being_assigned */, name !== undefined ? declarationNameToString(getSourceFileOfNode(name), name) : '');
+        return none();
+    }
+    // Referenced members must be declared earlier, in this enum or another.
+    if (!isBlockScopedNameDeclaredBeforeUse(c, declaration, location)) {
+        c.error(expr, 785 /* Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums */);
+        return EvaluatorResult.number(0);
+    }
+    computeEnumMemberValues(c, declaration.parent);
+    const links = c.nodeLinks(declaration);
+    if (links.enumValueKind === 1 /* EvaluatedKind.Number */)
+        return withFlags(EvaluatorResult.number(links.enumNumberValue), links.enumValueFlags);
+    if (links.enumValueKind === 2 /* EvaluatedKind.String */)
+        return withFlags(EvaluatorResult.string(links.enumStringValue), links.enumValueFlags);
+    return none();
+}
+function valueText(v) {
+    return v.kind === 1 /* EvaluatedKind.Number */ ? String(v.numberValue) : v.stringValue;
+}

package/dist/api/compiler/checker-expressions.d.ts

@@ -0,0 +1,67 @@
+import { type Identifier, type Node, type PropertyAccessExpression, type QualifiedName } from './ast.js';
+import { type Symbol } from './symbol.js';
+import { type Checker } from './checker.js';
+import { CheckMode, type Type } from './checker-types.js';
+export { getContextuallyTypedParameterType, isContextSensitiveFunctionOrObjectLiteralMethod, } from './checker-contextual.js';
+export declare function checkExpression(c: Checker, node: Node): Type;
+export declare function checkExpressionEx(c: Checker, node: Node, checkMode: CheckMode): Type;
+/** The type of `node`, computed once. */
+export declare function checkExpressionCached(c: Checker, node: Node): Type;
+/** The type of an expression, cached when computing it needed flow analysis; may skip some diagnostics. */
+export declare function getTypeOfExpression(c: Checker, node: Node): Type;
+/** The type of an initializer in a position where literals widen unless the context wants them. */
+export declare function checkExpressionForMutableLocation(c: Checker, node: Node): Type;
+export declare function checkExpressionForMutableLocationEx(c: Checker, node: Node, checkMode: CheckMode): Type;
+export declare function checkDeclarationInitializer(c: Checker, declaration: Node, checkMode?: CheckMode, contextualType?: Type): Type;
+export declare function checkComputedPropertyName(c: Checker, node: Node): Type;
+/** Whether `node` is the `this` of `typeof this` or `typeof this.x`, which parses as an identifier. */
+export declare function isThisInTypeQuery(node: Node): boolean;
+/** The type of the expression in a `typeof` type query. */
+export declare function checkTypeQueryExpression(c: Checker, node: Node): Type;
+/** The symbol an identifier refers to as a value; reports unresolved names. */
+export declare function getResolvedSymbol(c: Checker, node: Node): Symbol;
+export declare function parseBigIntText(text: string): string;
+export declare function checkIdentifier(c: Checker, node: Identifier, checkMode?: CheckMode): Type;
+/**
+ * A reference's type with union constraints substituted for generic types where only the
+ * constraint matters, so narrowing can apply: in constraint positions like `x.p`, or with a
+ * non-generic contextual type.
+ */
+export declare function getNarrowableTypeForReference(c: Checker, t: Type, reference: Node, checkMode?: CheckMode): Type;
+export declare function someTypeIsGenericWithUnionConstraint(c: Checker, t: Type): boolean;
+export declare function isInAmbientOrTypeNode(node: Node): boolean;
+export declare function checkThisExpression(c: Checker, node: Node): Type;
+/** The `this` type of a function expression or method from its context, such as its object literal. */
+export declare function getContextualThisParameterType(c: Checker, func: Node): Type | undefined;
+export declare function isTupleLikeType(c: Checker, t: Type): boolean;
+/** Whether `t` is a mutable array, a mutable tuple, or assignable to `any[]`. */
+export declare function isMutableArrayLikeType(c: Checker, t: Type): boolean;
+/** The name of an object literal element, or undefined when it's computed and not a literal. */
+export declare function getPropertyNameOfObjectLiteralElement(c: Checker, element: Node): string | undefined;
+/** Whether `node` is in an `as const` context, where literals keep their types. */
+export declare function isConstContext(c: Checker, node: Node): boolean;
+export declare function isConstTypeReference(node: Node): boolean;
+/** Widens a literal type unless the contextual type calls for literals of its kind. */
+export declare function getWidenedLiteralLikeTypeForContextualType(c: Checker, t: Type, contextualType: Type | undefined): Type;
+export declare function isLiteralOfContextualType(c: Checker, candidate: Type, contextualType: Type | undefined): boolean;
+/**
+ * The type of an expression used as an object, with `null` and `undefined` removed. Without
+ * narrowing, nullability errors are only reported where no narrowing could apply.
+ */
+export declare function checkNonNullExpression(c: Checker, node: Node): Type;
+export declare function checkNonNullType(c: Checker, t: Type, node: Node): Type;
+/** `checkNonNullType`, reporting a possibly nullish callee of a call when `isCallee`. */
+export declare function checkNonNullTypeEx(c: Checker, t: Type, node: Node, isCallee: boolean): Type;
+/** `checkNonNullType`, also reporting a `void` type as possibly undefined. */
+export declare function checkNonNullNonVoidType(c: Checker, t: Type, node: Node): Type;
+export declare function entityNameToString(node: Node): string;
+/** The type of `obj.name`; `writeOnly` gives the type it can be assigned, as for compound assignments. */
+export declare function checkPropertyAccessExpression(c: Checker, node: PropertyAccessExpression, writeOnly: boolean, checkMode?: CheckMode): Type;
+export declare function checkQualifiedName(c: Checker, node: QualifiedName): Type;
+export declare function getFlowTypeOfAccessExpression(c: Checker, node: Node, prop: Symbol | undefined, propTypeIn: Type, errorNode: Node, checkMode?: CheckMode): Type;
+/** Checks that the index of a generic indexed access is assignable to `keyof` its object type. */
+export declare function checkIndexedAccessIndexType(c: Checker, t: Type, accessNode: Node): Type;
+/** Checks that an assertion's operand type and asserted type are comparable. */
+export declare function checkAssertionDeferred(c: Checker, node: Node): void;
+/** Reports `source` not assignable to `target` at `errorNode`. */
+export declare function checkTypeAssignableToAndOptionallyElaborate(c: Checker, source: Type, target: Type, errorNode: Node, expr: Node | undefined): boolean;