xbintsc 0.5.22 → 0.5.31

package/src/checker/type-infer.ts

@@ -0,0 +1,185 @@
+/**
+ * Inference from expressions into the checker's type model.
+ *
+ * It is deliberately shallow: literals, object/array literals, `new`, function
+ * expressions and the obvious operators are inferred; calls, property reads and
+ * everything else are `any` here (the type-check walk refines them with flow).
+ */
+
+import {
+  SyntaxKind,
+  type ArrowFunction,
+  type ArrayLiteralExpression,
+  type AsExpression,
+  type BinaryExpression,
+  type ClassDeclaration,
+  type ConditionalExpression,
+  type Expression,
+  type FunctionExpression,
+  type Identifier,
+  type NewExpression,
+  type ObjectLiteralExpression,
+  type Parameter,
+  type ShorthandPropertyAssignment,
+  type TypeNode,
+} from "../ast/nodes.js";
+import { SymbolKind, type BindResult, type SymbolInfo } from "../binder/binder.js";
+import { classMemberName } from "../binder/helpers.js";
+import { ASSIGNMENT_OPERATORS } from "../codegen/generator/tables.js";
+import { ANY, isAny, isThisParameter, primitive, unionOf, widenType, type ParameterInfo, type PropertyInfo, type Type } from "./type-model.js";
+
+export interface InferenceContext {
+  readonly binding: BindResult;
+  resolve(node: TypeNode | undefined, typeParams?: ReadonlyMap<string, Type>): Type;
+  typeOfSymbol(symbol: SymbolInfo): Type;
+  classInstanceType(node: ClassDeclaration): Type;
+  parameterInfo(parameter: Parameter, typeParams: ReadonlyMap<string, Type>): ParameterInfo;
+}
+
+export function inferTypeOfExpression(
+  context: InferenceContext,
+  expression: Expression,
+  lookup?: (symbol: SymbolInfo) => Type | undefined,
+): Type {
+    switch (expression.kind) {
+      case SyntaxKind.NumericLiteral:
+        return { kind: "literal", value: (expression as { value: number }).value, primitive: "number" };
+      case SyntaxKind.StringLiteral:
+      case SyntaxKind.NoSubstitutionTemplateLiteral:
+        return { kind: "literal", value: (expression as { value: string }).value, primitive: "string" };
+      case SyntaxKind.TrueKeyword:
+        return { kind: "literal", value: true, primitive: "boolean" };
+      case SyntaxKind.FalseKeyword:
+        return { kind: "literal", value: false, primitive: "boolean" };
+      case SyntaxKind.NullKeyword:
+        return primitive("null");
+      case SyntaxKind.UndefinedKeyword:
+        return primitive("undefined");
+      case SyntaxKind.BigIntLiteral:
+        return primitive("bigint");
+      case SyntaxKind.Identifier: {
+        const symbol = context.binding.symbolOfIdentifier.get(expression as Identifier);
+        if (!symbol) return ANY;
+        return lookup?.(symbol) ?? context.typeOfSymbol(symbol);
+      }
+      case SyntaxKind.ObjectLiteralExpression:
+        return objectLiteralType(context, expression as ObjectLiteralExpression);
+      case SyntaxKind.ArrayLiteralExpression: {
+        const elements = (expression as ArrayLiteralExpression).elements.map((element) => {
+          if (element.kind !== SyntaxKind.SpreadElement) return inferTypeOfExpression(context, element, lookup);
+          const spread = inferTypeOfExpression(context, (element as unknown as { expression: Expression }).expression, lookup);
+          return spread.kind === "array" ? spread.element : ANY;
+        });
+        return { kind: "array", element: widenType(unionOf(elements)) };
+      }
+      case SyntaxKind.NewExpression: {
+        const call = expression as NewExpression;
+        if (call.expression.kind !== SyntaxKind.Identifier) return ANY;
+        const symbol = context.binding.symbolOfIdentifier.get(call.expression as Identifier);
+        if (!symbol || symbol.kind !== SymbolKind.Class || symbol.declarations.length !== 1) return ANY;
+        const declaration = symbol.declarations[0]!;
+        if (declaration.kind !== SyntaxKind.ClassDeclaration) return ANY;
+        return context.classInstanceType(declaration as ClassDeclaration);
+      }
+      case SyntaxKind.ArrowFunction:
+      case SyntaxKind.FunctionExpression:
+        return functionExpressionType(context, expression as ArrowFunction | FunctionExpression);
+      case SyntaxKind.AsExpression:
+        return context.resolve((expression as AsExpression).type);
+      case SyntaxKind.SatisfiesExpression:
+      case SyntaxKind.ParenthesizedExpression:
+      case SyntaxKind.NonNullExpression:
+        return inferTypeOfExpression(context, (expression as unknown as { expression: Expression }).expression, lookup);
+      case SyntaxKind.TypeOfExpression:
+        return primitive("string");
+      case SyntaxKind.VoidExpression:
+        return primitive("undefined");
+      case SyntaxKind.TemplateLiteral:
+        return primitive("string");
+      case SyntaxKind.ConditionalExpression: {
+        const conditional = expression as ConditionalExpression;
+        return unionOf([inferTypeOfExpression(context, conditional.whenTrue, lookup), inferTypeOfExpression(context, conditional.whenFalse, lookup)]);
+      }
+      case SyntaxKind.SequenceExpression: {
+        const expressions = (expression as unknown as { expressions: Expression[] }).expressions;
+        return inferTypeOfExpression(context, expressions[expressions.length - 1]!, lookup);
+      }
+      case SyntaxKind.BinaryExpression: {
+        const binary = expression as BinaryExpression;
+        if (binary.operator === "+") {
+          const left = inferTypeOfExpression(context, binary.left, lookup);
+          const right = inferTypeOfExpression(context, binary.right, lookup);
+          if (isAny(left) || isAny(right)) return ANY;
+          if (isBigIntish(left) || isBigIntish(right)) return primitive("bigint");
+          if (isStringish(left) || isStringish(right)) return primitive("string");
+          return primitive("number");
+        }
+        if (ASSIGNMENT_OPERATORS.has(binary.operator)) return ANY;
+        if (["<", "<=", ">", ">=", "==", "!=", "===", "!==", "in", "instanceof"].includes(binary.operator)) return primitive("boolean");
+        if (binary.operator === "&&" || binary.operator === "||" || binary.operator === "??") {
+          return unionOf([inferTypeOfExpression(context, binary.left, lookup), inferTypeOfExpression(context, binary.right, lookup)]);
+        }
+        const left = inferTypeOfExpression(context, binary.left, lookup);
+        const right = inferTypeOfExpression(context, binary.right, lookup);
+        if (isAny(left) || isAny(right)) return ANY;
+        if (isBigIntish(left) || isBigIntish(right)) return primitive("bigint");
+        return primitive("number");
+      }
+      case SyntaxKind.PrefixUnaryExpression: {
+        const operator = (expression as { operator: string }).operator;
+        if (operator === "typeof") return primitive("string");
+        if (operator === "!") return primitive("boolean");
+        if (operator === "void") return primitive("undefined");
+        return primitive("number");
+      }
+      case SyntaxKind.PostfixUnaryExpression:
+        return primitive("number");
+      case SyntaxKind.CallExpression:
+        return ANY;
+      case SyntaxKind.PropertyAccessExpression:
+        return ANY;
+      default:
+        return ANY;
+    }
+  }
+
+function objectLiteralType(context: InferenceContext, literal: ObjectLiteralExpression): Type {
+    const properties = new Map<string, PropertyInfo>();
+    for (const element of literal.properties) {
+      if (element.kind === SyntaxKind.PropertyAssignment) {
+        const property = element as { name: Parameters<typeof classMemberName>[0]; initializer: Expression; accessor?: "get" | "set" };
+        const name = classMemberName(property.name);
+        if (!name) return ANY;
+        // A getter/setter pair is a value property, not a function property;
+        // its exact type is not inferred here.
+        const type = property.accessor ? ANY : widenType(inferTypeOfExpression(context, property.initializer));
+        if (!(property.accessor === "set" && properties.has(name))) properties.set(name, { type, optional: false });
+      } else if (element.kind === SyntaxKind.ShorthandPropertyAssignment) {
+        const shorthand = element as ShorthandPropertyAssignment;
+        properties.set(shorthand.name.text, { type: inferTypeOfExpression(context, shorthand.name), optional: false });
+      } else {
+        return ANY; // spread: the shape is not static
+      }
+    }
+    return { kind: "object", properties, closed: true };
+  }
+
+function functionExpressionType(context: InferenceContext, expression: ArrowFunction | FunctionExpression): Type {
+    const typeParams = new Map<string, Type>();
+    return {
+      kind: "function",
+      parameters: expression.parameters.filter((parameter) => !isThisParameter(parameter)).map((parameter) => context.parameterInfo(parameter, typeParams)),
+      returnType: context.resolve(expression.returnType, typeParams),
+      typeParameters: (expression.typeParameters ?? []).map((parameter) => ({ name: parameter.name.text })),
+    };
+  }
+
+function isStringish(type: Type): boolean {
+  if (type.kind === "primitive") return type.name === "string";
+  if (type.kind === "literal") return type.primitive === "string";
+  return false;
+}
+
+function isBigIntish(type: Type): boolean {
+  return (type.kind === "primitive" && type.name === "bigint");
+}

package/src/checker/type-model.ts

@@ -0,0 +1,212 @@
+/**
+ * The value model used by the checker: a deliberately small structural type
+ * union plus the helpers shared by resolution and assignability.
+ */
+
+import {
+  ModifierKind,
+  SyntaxKind,
+  type Expression,
+  type Identifier,
+  type Parameter,
+} from "../ast/nodes.js";
+
+export type PrimitiveName =
+  | "number"
+  | "string"
+  | "boolean"
+  | "bigint"
+  | "symbol"
+  | "null"
+  | "undefined"
+  | "void"
+  | "object";
+
+export interface PropertyInfo {
+  readonly type: Type;
+  readonly optional: boolean;
+}
+
+export interface ParameterInfo {
+  readonly type: Type;
+  readonly optional: boolean;
+  readonly rest: boolean;
+}
+
+export interface TypeParameterInfo {
+  readonly name: string;
+  readonly constraint?: Type;
+}
+
+export type Type =
+  | { readonly kind: "any" }
+  | { readonly kind: "primitive"; readonly name: PrimitiveName }
+  | { readonly kind: "literal"; readonly value: string | number | boolean; readonly primitive: "string" | "number" | "boolean" }
+  | { readonly kind: "array"; readonly element: Type }
+  | { readonly kind: "tuple"; readonly elements: readonly Type[] }
+  | {
+      readonly kind: "object";
+      readonly properties: ReadonlyMap<string, PropertyInfo>;
+      readonly index?: Type;
+      /** False when the shape is open (index signature, `object`, ...). */
+      readonly closed: boolean;
+      readonly label?: string;
+    }
+  | {
+      readonly kind: "function";
+      readonly parameters: readonly ParameterInfo[];
+      readonly returnType: Type;
+      readonly typeParameters: readonly TypeParameterInfo[];
+      readonly label?: string;
+    }
+  | { readonly kind: "union"; readonly members: readonly Type[] }
+  | { readonly kind: "typeParam"; readonly name: string };
+
+export const ANY: Type = { kind: "any" };
+export const UNKNOWN: Type = { kind: "any" }; // no strict unknown mode: treat like any
+
+/** Own properties every object inherits from `Object.prototype`. */
+export const OBJECT_PROTOTYPE_NAMES: ReadonlySet<string> = new Set([
+  "constructor",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+  "toString",
+  "valueOf",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__",
+  "__proto__",
+]);
+
+export function isAny(type: Type): boolean {
+  return type.kind === "any" || type.kind === "typeParam";
+}
+
+export function primitive(name: PrimitiveName): Type {
+  return { kind: "primitive", name };
+}
+
+export function unionOf(members: readonly Type[]): Type {
+  const flattened: Type[] = [];
+  for (const member of members) {
+    if (member.kind === "any" || member.kind === "typeParam") return ANY;
+    if (member.kind === "union") flattened.push(...member.members);
+    else flattened.push(member);
+  }
+  const unique: Type[] = [];
+  for (const member of flattened) {
+    if (!unique.some((other) => sameType(member, other))) unique.push(member);
+  }
+  if (unique.length === 0) return ANY;
+  if (unique.length === 1) return unique[0]!;
+  return { kind: "union", members: unique };
+}
+
+export function unionMembers(type: Type): readonly Type[] {
+  return type.kind === "union" ? type.members : [type];
+}
+
+/**
+ * Widen the literal types TypeScript widens for a mutable position: `let x =
+ * 1` and object/array literal members are `number`, not the literal `1`.
+ * (`const x = 1` keeps the literal; the caller decides when to widen.)
+ */
+export function widenType(type: Type): Type {
+  switch (type.kind) {
+    case "literal":
+      return primitive(type.primitive);
+    case "array":
+      return { kind: "array", element: widenType(type.element) };
+    case "tuple":
+      return { kind: "tuple", elements: type.elements.map((element) => widenType(element)) };
+    case "union":
+      return unionOf(type.members.map((member) => widenType(member)));
+    case "object": {
+      const properties = new Map<string, PropertyInfo>();
+      for (const [name, property] of type.properties) {
+        properties.set(name, { type: widenType(property.type), optional: property.optional });
+      }
+      return {
+        kind: "object",
+        properties,
+        ...(type.index ? { index: widenType(type.index) } : {}),
+        closed: type.closed,
+        ...(type.label ? { label: type.label } : {}),
+      };
+    }
+    default:
+      return type;
+  }
+}
+
+function sameType(a: Type, b: Type): boolean {
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "primitive" && b.kind === "primitive") return a.name === b.name;
+  if (a.kind === "literal" && b.kind === "literal") return a.value === b.value;
+  if (a.kind === "typeParam" && b.kind === "typeParam") return a.name === b.name;
+  return false;
+}
+
+export function printType(type: Type, depth = 0): string {
+  if (depth > 3) return "...";
+  switch (type.kind) {
+    case "any":
+      return "any";
+    case "primitive":
+      return type.name;
+    case "literal":
+      return typeof type.value === "string" ? JSON.stringify(type.value) : String(type.value);
+    case "array":
+      return `${printType(type.element, depth + 1)}[]`;
+    case "tuple":
+      return `[${type.elements.map((element) => printType(element, depth + 1)).join(", ")}]`;
+    case "union":
+      return type.members.map((member) => printType(member, depth + 1)).join(" | ");
+    case "function": {
+      const params = type.parameters.map((parameter) => `${parameter.rest ? "..." : ""}${printType(parameter.type, depth + 1)}${parameter.optional ? "?" : ""}`);
+      return `(${params.join(", ")}) => ${printType(type.returnType, depth + 1)}`;
+    }
+    case "typeParam":
+      return type.name;
+    case "object": {
+      if (type.label) return type.label;
+      const entries = [...type.properties.entries()].slice(0, 6).map(([name, property]) => `${name}${property.optional ? "?" : ""}: ${printType(property.type, depth + 1)}`);
+      if (type.properties.size > 6) entries.push("...");
+      return `{ ${entries.join("; ")} }`;
+    }
+  }
+}
+
+/** Shared unwrapping for erased expression wrappers. */
+export function unwrap(expression: Expression): Expression {
+  let current = expression;
+  for (;;) {
+    if (
+      current.kind === SyntaxKind.AsExpression ||
+      current.kind === SyntaxKind.SatisfiesExpression ||
+      current.kind === SyntaxKind.NonNullExpression ||
+      current.kind === SyntaxKind.ParenthesizedExpression
+    ) {
+      current = (current as unknown as { expression: Expression }).expression;
+      continue;
+    }
+    return current;
+  }
+}
+
+export function isThisParameter(parameter: Parameter): boolean {
+  return parameter.name.kind === SyntaxKind.Identifier && (parameter.name as Identifier).text === "this";
+}
+
+export function isParameterProperty(parameter: Parameter): boolean {
+  return parameter.modifiers.some(
+    (modifier) =>
+      modifier.modifierKind === ModifierKind.Public ||
+      modifier.modifierKind === ModifierKind.Private ||
+      modifier.modifierKind === ModifierKind.Protected ||
+      modifier.modifierKind === ModifierKind.Readonly,
+  );
+}