@tilua/parser 1.0.1 → 1.1.0

package/README.md

@@ -298,6 +298,18 @@ call needed it — and the receiver is passed as the call's first argument. An
 answer of `undefined` leaves an ordinary Luau method call, which is what
 `text:upper()` wants, since a string already answers to it.
 
+A call can also carry more than was written. Every hook is told `at`, where
+the call was written (`{ file, line, column }`), and `arguments`: each one's
+type, that type as text, the code it was written as, and, for a name, the
+code of what it names. An answer's `prepend` lists Luau expressions to pass
+ahead of the written arguments. `globalCall` answers for a call to a global,
+such as `print(x)`, and `globalValue` for a global read as a value, such as
+`local p = print`. A local with the same name belongs to the author, and no
+hook is asked about it. A runtime can read `__LINES__`, the bundle's line map
+(`nil` outside a bundle), to turn a line Luau reports back into a place in the
+project. `console:log`, `print` and `error` in `@tilua-types/lua` are built on
+these hooks.
+
 The compiler lowers the language and nothing else: `filter` appears nowhere in
 it.
 
@@ -406,6 +418,14 @@ method's type is `(this: Dog, ...) => R`, so `rex:speak()` supplies it the way
 `function T:m()` supplies `self`. `new Dog(x)` *is* `Dog.new(x)` — the same
 function, callable by hand and passable as a value.
 
+**`public` and `private`** go before a member — `private balance = 0`,
+`private static function check()`, `public get size()`. Leaving it out means
+public. A private member can be reached only inside the body of the class that
+declared it, including functions nested in its methods; a subclass is outside,
+as in TypeScript. It is a type check and nothing more: the member is an
+ordinary key at runtime. `public` and `private` stay ordinary names elsewhere,
+so `private: boolean` is still a field.
+
 A declaration names two things. As a **type**, `Dog` is the type of its
 instances, nominal the same way a `declare class` is: a table with the same
 members is not one, and only `Dog` and what extends it are assignable to it.

package/dist/index.cjs

@@ -1830,6 +1830,19 @@ var Parser = class {
   }
   parseClassMember() {
     const start = this.current();
+    let accessibility;
+    if ((this.checkIdentifierValue("public") || this.checkIdentifierValue("private")) && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=") && !this.punctuatorAt(1, "(")) {
+      accessibility = this.advance().value;
+    }
+    const member = this.parseClassMemberAfterAccessibility(start);
+    if (!accessibility || !member) return member;
+    if (member.type === "ClassConstructor") {
+      this.problem(`A constructor cannot be '${accessibility}'`);
+      return member;
+    }
+    return { ...member, accessibility };
+  }
+  parseClassMemberAfterAccessibility(start) {
     const isStatic = this.checkIdentifierValue("static") && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=");
     if (isStatic) this.advance();
     if (this.checkKeyword("function")) {
@@ -4498,7 +4511,12 @@ function substitute(t, subst) {
       return t.name && r.kind === "intersection" && !r.name ? { ...r, name: t.name } : r;
     }
     case "genericRef":
-      return { kind: "genericRef", name: t.name, typeArguments: t.typeArguments.map((a) => substitute(a, subst)) };
+      return {
+        kind: "genericRef",
+        name: t.name,
+        typeArguments: t.typeArguments.map((a) => substitute(a, subst)),
+        ...t.origin ? { origin: t.origin } : {}
+      };
     case "keyof":
       return { kind: "keyof", target: substitute(t.target, subst) };
     case "templateLiteral":
@@ -4658,6 +4676,7 @@ function optional(t) {
   return union([t, nilType]);
 }
 function widen(t) {
+  if (isAliasNamed(t)) return t;
   switch (t.kind) {
     case "literal":
       return primitive(t.base);
@@ -4697,7 +4716,7 @@ function isAssignable(rawA, rawB) {
   if (expandAlias) {
     if (a.kind === "genericRef" && b.kind !== "genericRef") a = expandAlias(a);
     else if (b.kind === "genericRef" && a.kind !== "genericRef") b = expandAlias(b);
-    else if (a.kind === "genericRef" && b.kind === "genericRef" && a.name !== b.name) {
+    else if (a.kind === "genericRef" && b.kind === "genericRef" && !sameRefTarget(a, b)) {
       a = expandAlias(a);
       b = expandAlias(b);
     }
@@ -4807,10 +4826,17 @@ function isAssignableInner(a, b) {
   }
   if (b.kind === "typeParam") return false;
   if (a.kind === "genericRef" || b.kind === "genericRef") {
-    return a.kind === "genericRef" && b.kind === "genericRef" && a.name === b.name && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
+    return a.kind === "genericRef" && b.kind === "genericRef" && sameRefTarget(a, b) && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
   }
   return false;
 }
+function isAliasNamed(t) {
+  if (t.kind === "object" || t.kind === "intersection") return t.name !== void 0;
+  return t.alias !== void 0;
+}
+function sameRefTarget(a, b) {
+  return a.name === b.name && (!a.origin || !b.origin || a.origin === b.origin);
+}
 function isNoValue(t) {
   return t.kind === "tuple" && t.elements.length === 0;
 }
@@ -5596,6 +5622,9 @@ var TypeAnalyzer = class {
   aliases = new AliasMap();
   /** Uninstantiated alias definitions, for `Name<Args>` instantiation. */
   aliasDefs = /* @__PURE__ */ new Map();
+  /** Put on every ref to one of `aliasDefs`, so a module that imports the
+   *  type expands the ref here rather than by its name there. */
+  origin = { expand: (t) => this.expand(t) };
   /** See `resolveClass`. */
   classTypes = /* @__PURE__ */ new WeakMap();
   /** See `instanceType` — one instance type per `class ... end`. */
@@ -5880,13 +5909,18 @@ var TypeAnalyzer = class {
   classIdentityCount = 0;
   /** The class whose members are being read, so `super` knows its base. */
   currentClass;
+  /** Every class whose body the checker is inside, innermost last — what
+   *  decides whether a `private` member may be reached. */
+  enclosingClasses = [];
   withClass(stmt, fn2) {
     const previous = this.currentClass;
     this.currentClass = stmt;
+    this.enclosingClasses.push(stmt);
     try {
       return fn2();
     } finally {
       this.currentClass = previous;
+      this.enclosingClasses.pop();
     }
   }
   /** What the class is known by. A declaration is known by its name, the way
@@ -6004,7 +6038,8 @@ var TypeAnalyzer = class {
     return {
       kind: "genericRef",
       name: stmt.name.name,
-      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0))
+      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0)),
+      origin: this.origin
     };
   }
   /** The class table: the statics, what it inherits from the class it
@@ -6103,8 +6138,11 @@ var TypeAnalyzer = class {
     return shape;
   }
   fillShape(stmt, shape) {
+    const className = this.className(stmt);
     const put = (isStatic, name, property) => {
-      (isStatic ? shape.statics : shape.instance).set(name, property);
+      const member = stmt.members.find((m) => m.type !== "ClassConstructor" && m.isStatic === isStatic && m.name.name === name && m.accessibility === "private");
+      const marked = member ? { ...property, private: { owner: stmt, className } } : property;
+      (isStatic ? shape.statics : shape.instance).set(name, marked);
     };
     for (const member of stmt.members) {
       if (member.type !== "ClassField") continue;
@@ -6569,7 +6607,8 @@ var TypeAnalyzer = class {
             return this.expand({
               kind: "genericRef",
               name: node.base,
-              typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+              typeArguments: node.typeArguments.map((a) => this.resolveType(a)),
+              origin: this.origin
             });
           }
           const imported = this.importedTypes.get(node.base);
@@ -6582,7 +6621,8 @@ var TypeAnalyzer = class {
           return this.expand({
             kind: "genericRef",
             name,
-            typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+            typeArguments: node.typeArguments.map((a) => this.resolveType(a)),
+            origin: this.origin
           });
         }
         return {
@@ -8408,6 +8448,7 @@ var TypeAnalyzer = class {
    *  resolving, which is what breaks re-entry on a recursive alias. */
   expand(t) {
     if (t.kind !== "genericRef") return t;
+    if (t.origin && t.origin !== this.origin) return t.origin.expand(t);
     const def = this.aliasDefs.get(t.name);
     if (!def) {
       const imported = this.importedTypes.get(t.name);
@@ -8558,6 +8599,28 @@ var TypeAnalyzer = class {
       message: names.length === 1 ? `'${names[0]}' does not exist on a string` : `'${briefType(key)}' does not name a member of a string`
     });
   }
+  /** A `private` member read from outside the class that declared it —
+   *  a subclass counts as outside, as in TypeScript. */
+  checkPrivateMember(node, object, name) {
+    if (!this.emitDiagnostics) return;
+    const raw = this.expand(object);
+    for (const part of raw.kind === "union" ? raw.types : [raw]) {
+      const t = this.deferredAccess(this.expand(part));
+      if (t.kind !== "object") continue;
+      const access = t.properties.get(name)?.private;
+      if (!access || this.insideClass(access.owner)) continue;
+      this.diagnostics.push({
+        node,
+        message: `Property '${name}' is private and only accessible within class '${access.className}'`
+      });
+      return;
+    }
+  }
+  /** Is the code being checked written inside `owner`'s body — its own
+   *  methods, or a class or function nested in them? */
+  insideClass(owner) {
+    return this.enclosingClasses.includes(owner);
+  }
   propertyType(raw, name) {
     const t = this.deferredAccess(this.expand(raw));
     if (t.kind === "object") {
@@ -8775,6 +8838,7 @@ var TypeAnalyzer = class {
       }
       case "MemberExpression": {
         const { type: obj, shortCircuits } = this.chainObject(expr, expr.object, env);
+        this.checkPrivateMember(expr.property, obj, expr.property.name);
         const key = this.refKeyOf(expr);
         const narrowed = key === void 0 ? void 0 : env.get(key);
         this.checkStringMember(expr, obj, literal(expr.property.name));
@@ -8910,6 +8974,7 @@ var TypeAnalyzer = class {
     });
   }
   inferMethodCall(expr, objType, env) {
+    this.checkPrivateMember(expr.method, objType, expr.method.name);
     const method = this.propertyType(objType, expr.method.name);
     const united = this.unionSignatures(method);
     const fns = united ?? this.overloadsOf(method);

package/dist/index.d.cts

@@ -377,11 +377,16 @@ type ClassMember = ClassField | ClassMethod | ClassAccessor | ClassConstructor;
 /** The two ways a class is written. Everything after parsing treats them
  *  alike: only the name and the type parameters differ. */
 type ClassLike = ClassDeclaration | ClassExpression;
+/** `public` / `private` written before a member. Only the type checker reads
+ *  it: a private member is still an ordinary key at runtime. */
+type ClassAccessibility = "public" | "private";
 /** `x: number` / `x = 1` / `static count = 0`. An instance field is assigned
  *  when the instance is built, before the constructor body runs; a `static`
  *  one is assigned on the class table, once. */
 interface ClassField extends BaseNode {
     type: "ClassField";
+    /** Left out, the member is public. */
+    accessibility?: ClassAccessibility;
     name: Identifier;
     isStatic: boolean;
     typeAnnotation?: TypeNode;
@@ -391,6 +396,8 @@ interface ClassField extends BaseNode {
  *  A `static` one is a plain function on the class table, with no `this`. */
 interface ClassMethod extends BaseNode {
     type: "ClassMethod";
+    /** Left out, the member is public. */
+    accessibility?: ClassAccessibility;
     name: Identifier;
     isStatic: boolean;
     func: FunctionBody;
@@ -401,6 +408,8 @@ interface ClassMethod extends BaseNode {
  *  property, run as a function. */
 interface ClassAccessor extends BaseNode {
     type: "ClassAccessor";
+    /** Left out, the member is public. */
+    accessibility?: ClassAccessibility;
     kind: "get" | "set";
     name: Identifier;
     isStatic: boolean;
@@ -1117,6 +1126,13 @@ interface ObjectProperty {
     type: Type;
     optional: boolean;
     readonly?: boolean;
+    /** A class member written `private`: reachable only from inside the class
+     *  that declared it. `owner` is that class's node, compared by identity;
+     *  `className` is how a diagnostic names it. Checked, never lowered. */
+    private?: {
+        owner: object;
+        className: string;
+    };
 }
 interface ObjectType {
     kind: "object";
@@ -1223,6 +1239,15 @@ interface GenericRefType {
     kind: "genericRef";
     name: string;
     typeArguments: Type[];
+    /** The module whose alias this names. A recursive alias is left as a ref
+     *  inside its own structure, and that ref travels with the type into every
+     *  module that imports it — where `name` may mean nothing, or a different
+     *  type. Expanding through `origin` reads the name where it was written. */
+    origin?: TypeOrigin;
+}
+/** A module's own alias resolution, handed out on the refs it creates. */
+interface TypeOrigin {
+    expand(t: GenericRefType): Type;
 }
 /** `keyof T`. */
 interface KeyofType {
@@ -1600,9 +1625,20 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
 
 interface LoweringPlugin {
     /** Luau the plugin needs in the output, by a key it chooses. Each is a
-     *  file's worth of source with `__NAME__` standing for the local the
-     *  compiler gives it, and each is emitted once, at the top of the output,
-     *  only if `use` asked for it:
+     *  file's worth of source, emitted once, at the top of the output, only if
+     *  `use` asked for it. Two names in it are filled in by the compiler:
+     *
+     *   - `__NAME__`, the local the compiler gives this runtime;
+     *   - `__LINES__`, an expression holding the bundle's line map —
+     *     `{ [bundleLine] = { "src/a.tilua", sourceLine } }` — or `nil` when
+     *     the output is not a bundle. It is what turns a line Luau reports at
+     *     runtime back into a place in the project;
+     *   - `__FAIL__`, the bundle's error reporter, or `nil` outside a bundle:
+     *     a function that takes an error and returns it with the bundle's
+     *     positions replaced by the project's, followed by a traceback of
+     *     those. It is an `xpcall` handler — the one the entry runs under —
+     *     so a runtime that runs a callback on a thread of its own can report
+     *     that callback's errors the same way.
      *
      *      local __NAME__ = {}
      *      function __NAME__.filter(t, test) ... end
@@ -1612,24 +1648,84 @@ interface LoweringPlugin {
      *  method call, which is what a value that answers to the method itself
      *  wants — `text:upper()` reaches Lua's own. */
     methodCall?(call: MethodCall): MethodLowering | undefined;
+    /** What a call to a global — `print(...)`, `error(...)` — becomes. Asked
+     *  only when the name really is the global: a local the author called
+     *  `print` is theirs. `undefined` leaves the call as it was written. */
+    globalCall?(call: GlobalCall): CallLowering | undefined;
+    /** What a global read as a value — `task.spawn(print, x)`, `local p =
+     *  print` — becomes: a Luau expression, usually built from `use(...)`.
+     *  There is no call site to describe here, so this is where a plugin
+     *  that rewrites calls keeps the rest of the program consistent with it. */
+    globalValue?(value: GlobalValue): string | undefined;
+}
+/** Where a call was written. */
+interface CallSite {
+    /** The file, relative to the project root with `/` separators, or
+     *  `undefined` when a single source was compiled with no name. */
+    readonly file: string | undefined;
+    /** 1-based. */
+    readonly line: number;
+    /** 1-based. */
+    readonly column: number;
+}
+/** What the compiler knows about one argument that the runtime will not. */
+interface ArgumentInfo {
+    /** Its type, as the analyzer worked it out. */
+    readonly type: Type | undefined;
+    /** That type as the editor would show it — `(x: number) => number` —
+     *  so a library can print it without depending on this package. */
+    readonly typeText: string | undefined;
+    /** The code it was written as, at the call. */
+    readonly source: string;
+    /** For a name, the code of what it names — the value of `const f = ...`,
+     *  or the whole `function f() { ... }` — when this file declares it. */
+    readonly declaration?: string;
+    /** Written `...xs`. */
+    readonly spread: boolean;
+}
+interface CallContext {
+    /** Where the call was written. */
+    readonly at: CallSite;
+    /** Each written argument, in order. */
+    readonly arguments: readonly ArgumentInfo[];
+    /** The local name the output gives one of `runtime`'s entries, emitting
+     *  it if this is the first call that needed it. */
+    use(runtime: string): string;
 }
-interface MethodCall {
+interface MethodCall extends CallContext {
     /** The name written after `:`. */
     readonly method: string;
     /** The receiver's type, as the analyzer worked it out. `undefined` when
      *  nothing typed it, where a plugin should decline rather than guess. */
     readonly receiver: Type | undefined;
+    /** The receiver's name when it is a global — `console` in
+     *  `console:log(x)` — and `undefined` for anything else, a local of the
+     *  same name included. */
+    readonly receiverGlobal: string | undefined;
     /** How many arguments were written. */
     readonly argumentCount: number;
-    /** The local name the output gives one of `runtime`'s entries, emitting
-     *  it if this is the first call that needed it. */
+}
+interface GlobalCall extends CallContext {
+    /** The global called. */
+    readonly name: string;
+}
+interface GlobalValue {
+    /** The global read. */
+    readonly name: string;
+    readonly at: CallSite;
     use(runtime: string): string;
 }
-interface MethodLowering {
+interface CallLowering {
     /** What to call instead: a name, or a `table.member` path — usually built
      *  from `use(...)`. */
     readonly callee: string;
-    /** Pass the receiver as the first argument. Default: yes. */
+    /** Luau expressions passed ahead of the written arguments — the call
+     *  site, say, or a table of what the compiler knew about them. */
+    readonly prepend?: readonly string[];
+}
+interface MethodLowering extends CallLowering {
+    /** Pass the receiver as the first argument, after `prepend`. Default:
+     *  yes. */
     readonly passReceiver?: boolean;
 }
 
@@ -1679,4 +1775,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallStatement, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NewExpression, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypePackNode, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VarargExpression, type VariableDeclaration, type VariadicTypeNode, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NewExpression, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypePackNode, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VarargExpression, type VariableDeclaration, type VariadicTypeNode, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };

package/dist/index.d.ts

@@ -377,11 +377,16 @@ type ClassMember = ClassField | ClassMethod | ClassAccessor | ClassConstructor;
 /** The two ways a class is written. Everything after parsing treats them
  *  alike: only the name and the type parameters differ. */
 type ClassLike = ClassDeclaration | ClassExpression;
+/** `public` / `private` written before a member. Only the type checker reads
+ *  it: a private member is still an ordinary key at runtime. */
+type ClassAccessibility = "public" | "private";
 /** `x: number` / `x = 1` / `static count = 0`. An instance field is assigned
  *  when the instance is built, before the constructor body runs; a `static`
  *  one is assigned on the class table, once. */
 interface ClassField extends BaseNode {
     type: "ClassField";
+    /** Left out, the member is public. */
+    accessibility?: ClassAccessibility;
     name: Identifier;
     isStatic: boolean;
     typeAnnotation?: TypeNode;
@@ -391,6 +396,8 @@ interface ClassField extends BaseNode {
  *  A `static` one is a plain function on the class table, with no `this`. */
 interface ClassMethod extends BaseNode {
     type: "ClassMethod";
+    /** Left out, the member is public. */
+    accessibility?: ClassAccessibility;
     name: Identifier;
     isStatic: boolean;
     func: FunctionBody;
@@ -401,6 +408,8 @@ interface ClassMethod extends BaseNode {
  *  property, run as a function. */
 interface ClassAccessor extends BaseNode {
     type: "ClassAccessor";
+    /** Left out, the member is public. */
+    accessibility?: ClassAccessibility;
     kind: "get" | "set";
     name: Identifier;
     isStatic: boolean;
@@ -1117,6 +1126,13 @@ interface ObjectProperty {
     type: Type;
     optional: boolean;
     readonly?: boolean;
+    /** A class member written `private`: reachable only from inside the class
+     *  that declared it. `owner` is that class's node, compared by identity;
+     *  `className` is how a diagnostic names it. Checked, never lowered. */
+    private?: {
+        owner: object;
+        className: string;
+    };
 }
 interface ObjectType {
     kind: "object";
@@ -1223,6 +1239,15 @@ interface GenericRefType {
     kind: "genericRef";
     name: string;
     typeArguments: Type[];
+    /** The module whose alias this names. A recursive alias is left as a ref
+     *  inside its own structure, and that ref travels with the type into every
+     *  module that imports it — where `name` may mean nothing, or a different
+     *  type. Expanding through `origin` reads the name where it was written. */
+    origin?: TypeOrigin;
+}
+/** A module's own alias resolution, handed out on the refs it creates. */
+interface TypeOrigin {
+    expand(t: GenericRefType): Type;
 }
 /** `keyof T`. */
 interface KeyofType {
@@ -1600,9 +1625,20 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
 
 interface LoweringPlugin {
     /** Luau the plugin needs in the output, by a key it chooses. Each is a
-     *  file's worth of source with `__NAME__` standing for the local the
-     *  compiler gives it, and each is emitted once, at the top of the output,
-     *  only if `use` asked for it:
+     *  file's worth of source, emitted once, at the top of the output, only if
+     *  `use` asked for it. Two names in it are filled in by the compiler:
+     *
+     *   - `__NAME__`, the local the compiler gives this runtime;
+     *   - `__LINES__`, an expression holding the bundle's line map —
+     *     `{ [bundleLine] = { "src/a.tilua", sourceLine } }` — or `nil` when
+     *     the output is not a bundle. It is what turns a line Luau reports at
+     *     runtime back into a place in the project;
+     *   - `__FAIL__`, the bundle's error reporter, or `nil` outside a bundle:
+     *     a function that takes an error and returns it with the bundle's
+     *     positions replaced by the project's, followed by a traceback of
+     *     those. It is an `xpcall` handler — the one the entry runs under —
+     *     so a runtime that runs a callback on a thread of its own can report
+     *     that callback's errors the same way.
      *
      *      local __NAME__ = {}
      *      function __NAME__.filter(t, test) ... end
@@ -1612,24 +1648,84 @@ interface LoweringPlugin {
      *  method call, which is what a value that answers to the method itself
      *  wants — `text:upper()` reaches Lua's own. */
     methodCall?(call: MethodCall): MethodLowering | undefined;
+    /** What a call to a global — `print(...)`, `error(...)` — becomes. Asked
+     *  only when the name really is the global: a local the author called
+     *  `print` is theirs. `undefined` leaves the call as it was written. */
+    globalCall?(call: GlobalCall): CallLowering | undefined;
+    /** What a global read as a value — `task.spawn(print, x)`, `local p =
+     *  print` — becomes: a Luau expression, usually built from `use(...)`.
+     *  There is no call site to describe here, so this is where a plugin
+     *  that rewrites calls keeps the rest of the program consistent with it. */
+    globalValue?(value: GlobalValue): string | undefined;
+}
+/** Where a call was written. */
+interface CallSite {
+    /** The file, relative to the project root with `/` separators, or
+     *  `undefined` when a single source was compiled with no name. */
+    readonly file: string | undefined;
+    /** 1-based. */
+    readonly line: number;
+    /** 1-based. */
+    readonly column: number;
+}
+/** What the compiler knows about one argument that the runtime will not. */
+interface ArgumentInfo {
+    /** Its type, as the analyzer worked it out. */
+    readonly type: Type | undefined;
+    /** That type as the editor would show it — `(x: number) => number` —
+     *  so a library can print it without depending on this package. */
+    readonly typeText: string | undefined;
+    /** The code it was written as, at the call. */
+    readonly source: string;
+    /** For a name, the code of what it names — the value of `const f = ...`,
+     *  or the whole `function f() { ... }` — when this file declares it. */
+    readonly declaration?: string;
+    /** Written `...xs`. */
+    readonly spread: boolean;
+}
+interface CallContext {
+    /** Where the call was written. */
+    readonly at: CallSite;
+    /** Each written argument, in order. */
+    readonly arguments: readonly ArgumentInfo[];
+    /** The local name the output gives one of `runtime`'s entries, emitting
+     *  it if this is the first call that needed it. */
+    use(runtime: string): string;
 }
-interface MethodCall {
+interface MethodCall extends CallContext {
     /** The name written after `:`. */
     readonly method: string;
     /** The receiver's type, as the analyzer worked it out. `undefined` when
      *  nothing typed it, where a plugin should decline rather than guess. */
     readonly receiver: Type | undefined;
+    /** The receiver's name when it is a global — `console` in
+     *  `console:log(x)` — and `undefined` for anything else, a local of the
+     *  same name included. */
+    readonly receiverGlobal: string | undefined;
     /** How many arguments were written. */
     readonly argumentCount: number;
-    /** The local name the output gives one of `runtime`'s entries, emitting
-     *  it if this is the first call that needed it. */
+}
+interface GlobalCall extends CallContext {
+    /** The global called. */
+    readonly name: string;
+}
+interface GlobalValue {
+    /** The global read. */
+    readonly name: string;
+    readonly at: CallSite;
     use(runtime: string): string;
 }
-interface MethodLowering {
+interface CallLowering {
     /** What to call instead: a name, or a `table.member` path — usually built
      *  from `use(...)`. */
     readonly callee: string;
-    /** Pass the receiver as the first argument. Default: yes. */
+    /** Luau expressions passed ahead of the written arguments — the call
+     *  site, say, or a table of what the compiler knew about them. */
+    readonly prepend?: readonly string[];
+}
+interface MethodLowering extends CallLowering {
+    /** Pass the receiver as the first argument, after `prepend`. Default:
+     *  yes. */
     readonly passReceiver?: boolean;
 }
 
@@ -1679,4 +1775,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallStatement, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NewExpression, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypePackNode, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VarargExpression, type VariableDeclaration, type VariadicTypeNode, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NewExpression, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypePackNode, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type UnionType, type UnionTypeNode, type UnknownType, type VarargExpression, type VariableDeclaration, type VariadicTypeNode, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };

package/dist/index.js

@@ -1727,6 +1727,19 @@ var Parser = class {
   }
   parseClassMember() {
     const start = this.current();
+    let accessibility;
+    if ((this.checkIdentifierValue("public") || this.checkIdentifierValue("private")) && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=") && !this.punctuatorAt(1, "(")) {
+      accessibility = this.advance().value;
+    }
+    const member = this.parseClassMemberAfterAccessibility(start);
+    if (!accessibility || !member) return member;
+    if (member.type === "ClassConstructor") {
+      this.problem(`A constructor cannot be '${accessibility}'`);
+      return member;
+    }
+    return { ...member, accessibility };
+  }
+  parseClassMemberAfterAccessibility(start) {
     const isStatic = this.checkIdentifierValue("static") && !this.punctuatorAt(1, ":") && !this.operatorAt(1, "=");
     if (isStatic) this.advance();
     if (this.checkKeyword("function")) {
@@ -4395,7 +4408,12 @@ function substitute(t, subst) {
       return t.name && r.kind === "intersection" && !r.name ? { ...r, name: t.name } : r;
     }
     case "genericRef":
-      return { kind: "genericRef", name: t.name, typeArguments: t.typeArguments.map((a) => substitute(a, subst)) };
+      return {
+        kind: "genericRef",
+        name: t.name,
+        typeArguments: t.typeArguments.map((a) => substitute(a, subst)),
+        ...t.origin ? { origin: t.origin } : {}
+      };
     case "keyof":
       return { kind: "keyof", target: substitute(t.target, subst) };
     case "templateLiteral":
@@ -4555,6 +4573,7 @@ function optional(t) {
   return union([t, nilType]);
 }
 function widen(t) {
+  if (isAliasNamed(t)) return t;
   switch (t.kind) {
     case "literal":
       return primitive(t.base);
@@ -4594,7 +4613,7 @@ function isAssignable(rawA, rawB) {
   if (expandAlias) {
     if (a.kind === "genericRef" && b.kind !== "genericRef") a = expandAlias(a);
     else if (b.kind === "genericRef" && a.kind !== "genericRef") b = expandAlias(b);
-    else if (a.kind === "genericRef" && b.kind === "genericRef" && a.name !== b.name) {
+    else if (a.kind === "genericRef" && b.kind === "genericRef" && !sameRefTarget(a, b)) {
       a = expandAlias(a);
       b = expandAlias(b);
     }
@@ -4704,10 +4723,17 @@ function isAssignableInner(a, b) {
   }
   if (b.kind === "typeParam") return false;
   if (a.kind === "genericRef" || b.kind === "genericRef") {
-    return a.kind === "genericRef" && b.kind === "genericRef" && a.name === b.name && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
+    return a.kind === "genericRef" && b.kind === "genericRef" && sameRefTarget(a, b) && a.typeArguments.length === b.typeArguments.length && a.typeArguments.every((x, i) => equalTypes(x, b.typeArguments[i]));
   }
   return false;
 }
+function isAliasNamed(t) {
+  if (t.kind === "object" || t.kind === "intersection") return t.name !== void 0;
+  return t.alias !== void 0;
+}
+function sameRefTarget(a, b) {
+  return a.name === b.name && (!a.origin || !b.origin || a.origin === b.origin);
+}
 function isNoValue(t) {
   return t.kind === "tuple" && t.elements.length === 0;
 }
@@ -5493,6 +5519,9 @@ var TypeAnalyzer = class {
   aliases = new AliasMap();
   /** Uninstantiated alias definitions, for `Name<Args>` instantiation. */
   aliasDefs = /* @__PURE__ */ new Map();
+  /** Put on every ref to one of `aliasDefs`, so a module that imports the
+   *  type expands the ref here rather than by its name there. */
+  origin = { expand: (t) => this.expand(t) };
   /** See `resolveClass`. */
   classTypes = /* @__PURE__ */ new WeakMap();
   /** See `instanceType` — one instance type per `class ... end`. */
@@ -5777,13 +5806,18 @@ var TypeAnalyzer = class {
   classIdentityCount = 0;
   /** The class whose members are being read, so `super` knows its base. */
   currentClass;
+  /** Every class whose body the checker is inside, innermost last — what
+   *  decides whether a `private` member may be reached. */
+  enclosingClasses = [];
   withClass(stmt, fn2) {
     const previous = this.currentClass;
     this.currentClass = stmt;
+    this.enclosingClasses.push(stmt);
     try {
       return fn2();
     } finally {
       this.currentClass = previous;
+      this.enclosingClasses.pop();
     }
   }
   /** What the class is known by. A declaration is known by its name, the way
@@ -5901,7 +5935,8 @@ var TypeAnalyzer = class {
     return {
       kind: "genericRef",
       name: stmt.name.name,
-      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0))
+      typeArguments: params.map((p) => typeParam(p.name, p.constraint ? this.resolveType(p.constraint) : void 0)),
+      origin: this.origin
     };
   }
   /** The class table: the statics, what it inherits from the class it
@@ -6000,8 +6035,11 @@ var TypeAnalyzer = class {
     return shape;
   }
   fillShape(stmt, shape) {
+    const className = this.className(stmt);
     const put = (isStatic, name, property) => {
-      (isStatic ? shape.statics : shape.instance).set(name, property);
+      const member = stmt.members.find((m) => m.type !== "ClassConstructor" && m.isStatic === isStatic && m.name.name === name && m.accessibility === "private");
+      const marked = member ? { ...property, private: { owner: stmt, className } } : property;
+      (isStatic ? shape.statics : shape.instance).set(name, marked);
     };
     for (const member of stmt.members) {
       if (member.type !== "ClassField") continue;
@@ -6466,7 +6504,8 @@ var TypeAnalyzer = class {
             return this.expand({
               kind: "genericRef",
               name: node.base,
-              typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+              typeArguments: node.typeArguments.map((a) => this.resolveType(a)),
+              origin: this.origin
             });
           }
           const imported = this.importedTypes.get(node.base);
@@ -6479,7 +6518,8 @@ var TypeAnalyzer = class {
           return this.expand({
             kind: "genericRef",
             name,
-            typeArguments: node.typeArguments.map((a) => this.resolveType(a))
+            typeArguments: node.typeArguments.map((a) => this.resolveType(a)),
+            origin: this.origin
           });
         }
         return {
@@ -8305,6 +8345,7 @@ var TypeAnalyzer = class {
    *  resolving, which is what breaks re-entry on a recursive alias. */
   expand(t) {
     if (t.kind !== "genericRef") return t;
+    if (t.origin && t.origin !== this.origin) return t.origin.expand(t);
     const def = this.aliasDefs.get(t.name);
     if (!def) {
       const imported = this.importedTypes.get(t.name);
@@ -8455,6 +8496,28 @@ var TypeAnalyzer = class {
       message: names.length === 1 ? `'${names[0]}' does not exist on a string` : `'${briefType(key)}' does not name a member of a string`
     });
   }
+  /** A `private` member read from outside the class that declared it —
+   *  a subclass counts as outside, as in TypeScript. */
+  checkPrivateMember(node, object, name) {
+    if (!this.emitDiagnostics) return;
+    const raw = this.expand(object);
+    for (const part of raw.kind === "union" ? raw.types : [raw]) {
+      const t = this.deferredAccess(this.expand(part));
+      if (t.kind !== "object") continue;
+      const access = t.properties.get(name)?.private;
+      if (!access || this.insideClass(access.owner)) continue;
+      this.diagnostics.push({
+        node,
+        message: `Property '${name}' is private and only accessible within class '${access.className}'`
+      });
+      return;
+    }
+  }
+  /** Is the code being checked written inside `owner`'s body — its own
+   *  methods, or a class or function nested in them? */
+  insideClass(owner) {
+    return this.enclosingClasses.includes(owner);
+  }
   propertyType(raw, name) {
     const t = this.deferredAccess(this.expand(raw));
     if (t.kind === "object") {
@@ -8672,6 +8735,7 @@ var TypeAnalyzer = class {
       }
       case "MemberExpression": {
         const { type: obj, shortCircuits } = this.chainObject(expr, expr.object, env);
+        this.checkPrivateMember(expr.property, obj, expr.property.name);
         const key = this.refKeyOf(expr);
         const narrowed = key === void 0 ? void 0 : env.get(key);
         this.checkStringMember(expr, obj, literal(expr.property.name));
@@ -8807,6 +8871,7 @@ var TypeAnalyzer = class {
     });
   }
   inferMethodCall(expr, objType, env) {
+    this.checkPrivateMember(expr.method, objType, expr.method.name);
     const method = this.propertyType(objType, expr.method.name);
     const united = this.unionSignatures(method);
     const fns = united ?? this.overloadsOf(method);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/parser",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "tilua parser for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",