@thigasdevelopment/luam 0.4.0 → 0.4.1

package/luam.mjs

@@ -190,7 +190,7 @@ function parseArguments(argv) {
       continue;
     }
     if (parsed.command !== null) {
-      if (parsed.command === "trace" && parsed.operand === null) {
+      if ((parsed.command === "init" || parsed.command === "trace") && parsed.operand === null) {
         parsed.operand = token;
         continue;
       }
@@ -212,12 +212,13 @@ var EXIT_DIAGNOSTICS = 1;
 var EXIT_USAGE = 2;
 
 // src/cli/usage.ts
-var VERSION = true ? "0.4.0" : "0.0.0-dev";
+var VERSION = true ? "0.4.1" : "0.0.0-dev";
 var USAGE = [
   "luam \u2014 the Luam compiler for Multi Theft Auto resources.",
   "",
   "Usage:",
   "    luam <command> [options]",
+  "    luam init [path] [options]",
   "",
   "Commands:",
   "    build     Compile the project and write the resource to the output directory.",
@@ -225,16 +226,16 @@ var USAGE = [
   "    dev       Build, sync, restart, watch, and stream resource development logs.",
   "    doctor    Check the CLI, supported editors, and the Luam extension.",
   "    ensure    Build, sync the resource into the MTA server, and restart it.",
-  "    init      Scaffold a new resource project with the framework and example handlers.",
+  "    init      Interactively scaffold a new resource project.",
   "    setup     Detect supported editors and install the Luam extension with consent.",
   "    trace     Resolve generated Lua positions back to Luam source positions.",
   "",
   "Options:",
   "    --cwd <path>       Project directory that contains luam.json. Defaults to the current directory.",
   "    --config <path>    Configuration file to load instead of luam.json.",
-  "    --name <name>      Resource name for init. Defaults to the project directory name.",
+  "    --name <name>      Resource name for init. Defaults to the destination directory name.",
   "    --force            Let init overwrite files that already exist.",
-  "    -y, --yes          Install the extension in every detected editor without prompting.",
+  "    -y, --yes          Accept init defaults or install every detected editor without prompting.",
   "    --watch            Keep ensure or dev running and rebuild on source changes.",
   "    --no-watch         Run ensure or dev once and exit.",
   "    --bundle           Build or ensure with bundled output.",
@@ -1164,8 +1165,8 @@ var Binder = class {
   isDeclaredInCurrentScope(name) {
     return this.scopes[this.scopes.length - 1]?.has(name) ?? false;
   }
-  declareAlias(name, type) {
-    this.aliases.set(name, type);
+  declareAlias(name, type, parameters = []) {
+    this.aliases.set(name, { type, parameters });
   }
   lookupAlias(name) {
     return this.aliases.get(name) ?? null;
@@ -5005,6 +5006,35 @@ function mtaMember(className, member) {
   return mtaClassRegistry().lookupMember(className, member);
 }
 
+// ../compiler/src/checker/type-substitution.ts
+function substituteType(type, substitutions) {
+  if (type.kind === "named") {
+    return substitutions.get(type.name) ?? type;
+  }
+  if (type.kind === "array") {
+    return createArray(substituteType(type.element, substitutions));
+  }
+  if (type.kind === "optional") {
+    return createOptional(substituteType(type.element, substitutions));
+  }
+  if (type.kind === "union") {
+    return createUnion(type.options.map((option) => substituteType(option, substitutions)));
+  }
+  if (type.kind === "function") {
+    const parameters = type.parameters.map((parameter) => substituteType(parameter, substitutions));
+    const returnType = substituteType(type.returnType, substitutions);
+    return createFunction(parameters, returnType, type.minimumArguments, type.isVariadic);
+  }
+  if (type.kind === "tuple") {
+    return createTuple(type.elements.map((element) => substituteType(element, substitutions)));
+  }
+  if (type.kind === "record") {
+    const members = new Map([...type.members].map(([name, member]) => [name, substituteType(member, substitutions)]));
+    return createRecord(type.name, members, type.origin);
+  }
+  return type;
+}
+
 // ../compiler/src/checker/context.ts
 var BUILTIN_TYPES = {
   any: ANY_TYPE,
@@ -5086,13 +5116,32 @@ var CheckContext = class {
     return this.types.get(expression) ?? UNKNOWN_TYPE;
   }
   pushReturnType(type) {
-    this.returnStack.push(type);
+    this.returnStack.push({ expected: type, inferred: [] });
   }
   popReturnType() {
-    this.returnStack.pop();
+    const frame = this.returnStack.pop();
+    if (frame === void 0 || frame.inferred.length === 0) {
+      return VOID_TYPE;
+    }
+    const tuples = frame.inferred.filter((type) => type.kind === "tuple");
+    const tupleSize = tuples[0]?.kind === "tuple" ? tuples[0].elements.length : null;
+    const sameTupleSize = tuples.length === frame.inferred.length && tuples.every((type) => type.kind === "tuple" && type.elements.length === tupleSize);
+    if (sameTupleSize) {
+      const first = tuples[0];
+      if (first?.kind === "tuple") {
+        const elements = first.elements.map(
+          (_, index) => createUnion(tuples.map((type) => type.kind === "tuple" ? type.elements[index] ?? ANY_TYPE : ANY_TYPE))
+        );
+        return createTuple(elements);
+      }
+    }
+    return createUnion(frame.inferred);
   }
   currentReturnType() {
-    return this.returnStack[this.returnStack.length - 1] ?? null;
+    return this.returnStack[this.returnStack.length - 1]?.expected ?? null;
+  }
+  inferReturnType(type) {
+    this.returnStack[this.returnStack.length - 1]?.inferred.push(type);
   }
   pushClassMethod(frame) {
     this.methodStack.push(frame);
@@ -5132,7 +5181,7 @@ var CheckContext = class {
       const minimum = optional === -1 ? parameters.length : optional;
       return createFunction(parameters, this.resolveAnnotation(annotation.returnType), minimum, annotation.isVariadic);
     }
-    return this.resolveNamedAnnotation(annotation.name);
+    return this.resolveNamedAnnotation(annotation.name, annotation.typeArguments, annotation.position);
   }
   expectAssignable(source, target, position2, subject) {
     if (isAssignable(source, target, { allowNil: this.allowNil })) {
@@ -5168,12 +5217,25 @@ var CheckContext = class {
       this.binder.declareGlobal({ name: info.name, type: info.type, isLocal: false, position: info.position });
     }
   }
-  resolveNamedAnnotation(name) {
+  resolveNamedAnnotation(name, typeArguments, position2) {
     const builtin = BUILTIN_TYPES[name];
     if (builtin !== void 0) {
+      if (typeArguments.length > 0) {
+        this.report("check-generic-arity", `Type "${name}" does not accept type arguments.`, position2);
+      }
       return builtin;
     }
-    return this.binder.lookupAlias(name) ?? createNamed(name);
+    const alias = this.binder.lookupAlias(name);
+    if (alias === null) {
+      return createNamed(name);
+    }
+    if (typeArguments.length !== alias.parameters.length) {
+      const expected = alias.parameters.length === 1 ? "1 type argument" : `${alias.parameters.length} type arguments`;
+      this.report("check-generic-arity", `Type "${name}" expects ${expected} but received ${typeArguments.length}.`, position2);
+    }
+    const resolved = typeArguments.map((argument) => this.resolveAnnotation(argument));
+    const substitutions = new Map(alias.parameters.map((parameter, index) => [parameter, resolved[index] ?? ANY_TYPE]));
+    return substituteType(alias.type, substitutions);
   }
 };
 
@@ -6347,7 +6409,7 @@ function checkMultiValueExpression(context, expression) {
       return checkTable(context, expression);
     case "function-expression": {
       const type = buildFunctionType(context, expression.parameters, expression.returnAnnotation);
-      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, null);
+      checkFunctionBody(context, expression.parameters, expression.returnAnnotation, expression.body, type, null);
       return context.record(expression, type);
     }
     case "binary-expression": {
@@ -6412,8 +6474,12 @@ function checkMethodBody(context, info, member) {
   if (explicitSelf !== void 0) {
     context.report("check-explicit-self-parameter", 'Class methods receive "self" automatically; remove it from the parameter list.', explicitSelf.position);
   }
+  const signature = info.members.get(member.name)?.type;
+  if (signature?.kind !== "function") {
+    return;
+  }
   context.pushClassMethod({ className: info.name, methodName: member.name });
-  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, createNamed(info.name));
+  checkFunctionBody(context, member.parameters, member.returnAnnotation, member.body, signature, createNamed(info.name));
   context.popClassMethod();
 }
 function checkContract(context, info, contract, member) {
@@ -6600,9 +6666,9 @@ function buildFunctionType(context, parameters, returnAnnotation) {
   const types = parameters.filter((parameter) => !parameter.isVararg).map((parameter) => context.resolveAnnotation(parameter.annotation));
   return createFunction(types, context.resolveAnnotation(returnAnnotation), minimumArguments(context, parameters), isVariadic);
 }
-function checkFunctionBody(context, parameters, returnAnnotation, body, selfType) {
+function checkFunctionBody(context, parameters, returnAnnotation, body, signature, selfType) {
   context.binder.pushScope();
-  context.pushReturnType(context.resolveAnnotation(returnAnnotation));
+  context.pushReturnType(returnAnnotation === null ? null : context.resolveAnnotation(returnAnnotation));
   if (selfType !== null) {
     context.binder.declare({ name: "self", type: selfType, isLocal: true, position: ORIGIN });
   }
@@ -6611,7 +6677,10 @@ function checkFunctionBody(context, parameters, returnAnnotation, body, selfType
     context.binder.declare({ name: parameter.name, type, isLocal: true, position: parameter.position });
   }
   checkStatements(context, body);
-  context.popReturnType();
+  const inferred = context.popReturnType();
+  if (returnAnnotation === null) {
+    signature.returnType = inferred;
+  }
   context.binder.popScope();
 }
 function valueAt(values, valueTypes, index) {
@@ -6681,12 +6750,16 @@ function checkFunctionDeclaration(context, statement) {
     }
   }
   context.record(statement.name, type);
-  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, statement.isMethod ? ANY_TYPE : null);
+  checkFunctionBody(context, statement.parameters, statement.returnAnnotation, statement.body, type, statement.isMethod ? ANY_TYPE : null);
 }
 function checkReturn(context, statement) {
   const valueTypes = checkValueList(context, statement.values);
   const expected = context.currentReturnType();
-  if (expected === null || expected.kind === "any") {
+  if (expected === null) {
+    context.inferReturnType(createTuple(valueTypes));
+    return;
+  }
+  if (expected.kind === "any") {
     return;
   }
   if (expected.kind === "void") {
@@ -6761,7 +6834,7 @@ function checkStatement(context, statement) {
     case "type-alias-statement": {
       const resolved = context.resolveAnnotation(statement.annotation);
       const named2 = statement.annotation.kind === "type-object" ? renameRecord(resolved, statement.name) : resolved;
-      context.binder.declareAlias(statement.name, named2);
+      context.binder.declareAlias(statement.name, named2, statement.typeParameters);
       return;
     }
     case "declare-statement":
@@ -8483,6 +8556,14 @@ function parseLegacyClassMethod(stream, token, decorators) {
 function parseFieldAnnotation(stream) {
   return parseNamedAnnotation(stream, "field");
 }
+function expectClassFieldBoundary(stream, token) {
+  const current = stream.current();
+  const delimiter = current.kind === "punctuation" && (current.value === "}" || current.value === ";" || current.value === ",");
+  if (current.kind === "eof" || delimiter || current.position.line > token.position.line) {
+    return;
+  }
+  throw stream.error(`Expected a line break or separator after class member "${token.value}".`, "parse-unexpected-token");
+}
 function parseClassMember(stream) {
   const decorators = parseDecorators(stream);
   const token = stream.expectName();
@@ -8494,6 +8575,7 @@ function parseClassMember(stream) {
   }
   const annotation = parseFieldAnnotation(stream);
   const value = stream.match("operator", "=") ? parseExpression(stream) : null;
+  expectClassFieldBoundary(stream, token);
   return { kind: "class-field", name: token.value, annotation, value, decorators, position: token.position };
 }
 function parseClassModifiers(stream, declaration) {
@@ -11002,6 +11084,28 @@ async function runDevCommand(context, options) {
 // src/commands/init-command.ts
 import { basename } from "node:path";
 
+// src/commands/init-prompt.ts
+import { createInterface } from "node:readline/promises";
+async function question(prompt, label2, fallback) {
+  const answer = (await prompt.question(`${label2}${fallback === "" ? "" : ` (${fallback})`}: `)).trim();
+  return answer === "" ? fallback : answer;
+}
+async function promptForProject(defaults, nameLocked) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return defaults;
+  }
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const name = nameLocked ? defaults.name : await question(prompt, "Project name", defaults.name);
+    const version = await question(prompt, "Version", defaults.version);
+    const description = await question(prompt, "Description", defaults.description ?? "");
+    const author = await question(prompt, "Author", defaults.author ?? "");
+    return { name, version, description: description || null, author: author || null };
+  } finally {
+    prompt.close();
+  }
+}
+
 // src/config/config-schema.ts
 var CONFIG_FILE_NAME = "luam.json";
 var DEFAULT_SOURCE_DIRS = ["src"];
@@ -11049,21 +11153,29 @@ function readTemplateSource(source) {
 }
 
 // src/scaffold/scaffold-plan.ts
-function renderConfig(source, name) {
+function renderConfig(source, details) {
   const parsed = JSON.parse(source);
   const config = typeof parsed === "object" && parsed !== null ? parsed : {};
-  return `${JSON.stringify({ ...config, name, description: `The ${name} resource, scaffolded by luam init.` }, null, 4)}
+  const { name: _name, version: _version, description: _description, author: _author, ...template } = config;
+  const metadata = {
+    ...template,
+    name: details.name,
+    version: details.version,
+    ...details.description === null ? {} : { description: details.description },
+    ...details.author === null ? {} : { author: details.author }
+  };
+  return `${JSON.stringify(metadata, null, 4)}
 `;
 }
-function renderFile(file, name) {
+function renderFile(file, details) {
   const source = readTemplateSource(file.source);
   if (file.path !== CONFIG_FILE_NAME) {
     return { path: file.path, content: source };
   }
-  return { path: file.path, content: renderConfig(source, name) };
+  return { path: file.path, content: renderConfig(source, details) };
 }
-function buildScaffoldPlan(name) {
-  return { name, files: TEMPLATE_FILES.map((file) => renderFile(file, name)) };
+function buildScaffoldPlan(details) {
+  return { name: details.name, files: TEMPLATE_FILES.map((file) => renderFile(file, details)) };
 }
 
 // src/scaffold/scaffold-writer.ts
@@ -11094,21 +11206,31 @@ function resolveResourceName(root, requested) {
   const folder = basename(root);
   return isValidResourceName(folder) ? folder : FALLBACK_RESOURCE_NAME;
 }
-function runInitCommand(root, logger, options) {
+async function runInitCommand(root, logger, options) {
   if (options.name !== null && !isValidResourceName(options.name)) {
     logger.error(`"--name" must be a valid MTA resource name but received "${options.name}".`);
     return EXIT_USAGE;
   }
-  const name = resolveResourceName(root, options.name);
-  const result = writeScaffold(root, buildScaffoldPlan(name), options.force);
+  const defaults = {
+    name: resolveResourceName(root, options.name),
+    version: "1.0.0",
+    description: null,
+    author: null
+  };
+  const details = options.yes ? defaults : await options.prompt(defaults, options.name !== null);
+  if (!isValidResourceName(details.name)) {
+    logger.error(`"Project name" must be a valid MTA resource name but received "${details.name}".`);
+    return EXIT_USAGE;
+  }
+  const result = writeScaffold(root, buildScaffoldPlan(details), options.force);
   for (const path of result.skipped) {
     logger.warn(`Kept the existing "${path}". Pass "--force" to overwrite it.`);
   }
   if (result.written.length === 0) {
-    logger.info(`The project "${name}" already exists in "${root}". Nothing was written.`);
+    logger.info(`The project "${details.name}" already exists in "${root}". Nothing was written.`);
     return EXIT_OK;
   }
-  logger.info(`Scaffolded "${name}" into "${root}" (${result.written.length} files, ${result.skipped.length} kept).`);
+  logger.info(`Scaffolded "${details.name}" into "${root}" (${result.written.length} files, ${result.skipped.length} kept).`);
   logger.info('Next: run "luam check", then "luam build".');
   return EXIT_OK;
 }
@@ -11720,12 +11842,12 @@ function createEditorService() {
 }
 
 // src/editor/installation-prompt.ts
-import { createInterface } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 async function promptForInstallation(editorName) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     return null;
   }
-  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     const answer = (await prompt.question(`Install the Luam extension in ${editorName}? [Y/n] `)).trim().toLowerCase();
     return answer === "" || answer === "y" || answer === "yes";
@@ -11848,7 +11970,8 @@ async function runCli(argv, overrides = {}) {
   }
   const root = resolve12(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   if (parsed.command === "init") {
-    return runInitCommand(root, logger, { name: parsed.name, force: parsed.force });
+    const target = parsed.operand === null ? root : resolve12(root, parsed.operand);
+    return runInitCommand(target, logger, { name: parsed.name, force: parsed.force, yes: parsed.yes, prompt: overrides.initPrompt ?? promptForProject });
   }
   const editorService = overrides.editorService ?? createEditorService();
   if (parsed.command === "doctor") {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thigasdevelopment/luam",
-    "version": "0.4.0",
+    "version": "0.4.1",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",