@thigasdevelopment/luam 0.19.8 → 0.19.11

package/luam.mjs

@@ -4427,13 +4427,16 @@ function isCallStart(stream) {
   return stream.check("punctuation", "(") || stream.check("punctuation", "{") || stream.check("string") || stream.check("template");
 }
 function parseSuffixed(stream) {
+  const checkpoint = stream.checkpoint();
   let expression = parsePrimary(stream);
+  stream.recordSpan(expression, checkpoint);
   for (; ; ) {
     const token = stream.current();
     if (token.kind === "punctuation" && token.value === ".") {
       stream.next();
       const property = stream.expectName().value;
       expression = { kind: "member-expression", object: expression, property, position: token.position };
+      stream.recordSpan(expression, checkpoint);
       continue;
     }
     if (token.kind === "punctuation" && token.value === "[") {
@@ -4441,6 +4444,7 @@ function parseSuffixed(stream) {
       const index = parseExpression(stream);
       stream.expect("punctuation", "]");
       expression = { kind: "index-expression", object: expression, index, position: token.position };
+      stream.recordSpan(expression, checkpoint);
       continue;
     }
     if (token.kind === "punctuation" && token.value === ":" && stream.checkName(1)) {
@@ -4448,11 +4452,13 @@ function parseSuffixed(stream) {
       const method = stream.next().value;
       const typeArguments2 = parseCallTypeArguments(stream);
       expression = { kind: "call-expression", callee: expression, method, typeArguments: typeArguments2, args: parseArguments(stream), position: token.position };
+      stream.recordSpan(expression, checkpoint);
       continue;
     }
     const typeArguments = parseCallTypeArguments(stream);
     if (typeArguments.length > 0 || isCallStart(stream)) {
       expression = { kind: "call-expression", callee: expression, method: null, typeArguments, args: parseArguments(stream), position: token.position };
+      stream.recordSpan(expression, checkpoint);
       continue;
     }
     return expression;
@@ -6972,7 +6978,7 @@ import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/cli/version.ts
-var VERSION = true ? "0.19.8" : "0.0.0-dev";
+var VERSION = true ? "0.19.11" : "0.0.0-dev";
 var PROGRAM_NAME = "luam";
 var PROGRAM_DESCRIPTION = "luam \u2014 the Luam compiler for Multi Theft Auto resources.";
 
@@ -21909,14 +21915,15 @@ function canonicalEdit(input, statement, span) {
   if (trimmed.length === 0) {
     return erasedEdit(source, span);
   }
-  const authored = source.slice(span.start, span.end);
-  const replacement = reindent(trimmed, indentOf(source, span.start));
+  const end = erasedEnd(source, span);
+  const authored = source.slice(span.start, end);
+  const replacement = `${reindent(trimmed, indentOf(source, span.start))}${source.slice(span.end, end).trim()}`;
   const missing2 = lineCount2(authored) - lineCount2(replacement);
   if (missing2 < 0 && input.development) {
     return null;
   }
-  const padded = missing2 > 0 && source.slice(span.end).trim().length > 0 ? `${replacement}${"\n".repeat(missing2)}` : replacement;
-  return { start: span.start, end: span.end, replacement: padded, lines: emitted2.lines };
+  const padded = missing2 > 0 && source.slice(end).trim().length > 0 ? `${replacement}${"\n".repeat(missing2)}` : replacement;
+  return { start: span.start, end, replacement: padded, lines: emitted2.lines };
 }
 
 // ../compiler/src/emitter/preserve-decorators.ts
@@ -22059,7 +22066,11 @@ function selfEdit(source, member, span) {
   return { start: parenthesis + 1, end: parenthesis + 1, replacement: "self" };
 }
 function isKept(member) {
-  return !isLazyField(member) && (member.kind === "class-method" || member.value !== null);
+  return !isLazyField(member);
+}
+function declaredFieldEdit(source, member, end, separator) {
+  const start = member.position.offset;
+  return { start, end, replacement: `${member.name} = nil${separator}${blankSpan(source.slice(start, end))}` };
 }
 function isLazyField(member) {
   return member.kind === "class-field" && member.decorators.some((decorator) => decorator.name === "Lazy");
@@ -22120,6 +22131,13 @@ function classEdits(input, statement, spans) {
       edits.push({ start: span.start, end, replacement: isLazyField(member) ? longComment(text) : blankSpan(text) });
       continue;
     }
+    const needsSeparator2 = separator === null && (member !== kept[kept.length - 1] || injected !== null);
+    if (member.kind === "class-field" && member.value === null) {
+      const end = separator === null ? span.end : separator + 1;
+      const written = separator === null ? needsSeparator2 ? "," : "" : source.slice(separator, separator + 1);
+      edits.push(declaredFieldEdit(source, member, end, written));
+      continue;
+    }
     if (member.kind === "class-method" && !member.isStatic) {
       const self = selfEdit(source, member, span);
       if (self === null) {
@@ -22127,7 +22145,7 @@ function classEdits(input, statement, spans) {
       }
       edits.push(self);
     }
-    if (separator === null && (member !== kept[kept.length - 1] || injected !== null)) {
+    if (needsSeparator2) {
       edits.push({ start: span.end, end: span.end, replacement: "," });
     }
   }
@@ -22146,6 +22164,99 @@ function classEdits(input, statement, spans) {
   return edits;
 }
 
+// ../compiler/src/emitter/preserve-expressions.ts
+function children(expression) {
+  switch (expression.kind) {
+    case "member-expression":
+      return [expression.object];
+    case "index-expression":
+      return [expression.object, expression.index];
+    case "call-expression":
+      return [expression.callee, ...expression.args];
+    case "new-expression":
+      return [...expression.args];
+    case "table-expression":
+      return expression.fields.flatMap((field2) => field2.key === null ? [field2.value] : [field2.key, field2.value]);
+    case "binary-expression":
+      return [expression.left, expression.right];
+    case "unary-expression":
+      return [expression.operand];
+    case "group-expression":
+      return [expression.expression];
+    default:
+      return [];
+  }
+}
+function isOwnFailure(expression, types, statics) {
+  switch (expression.kind) {
+    case "template-literal":
+    case "new-expression":
+      return true;
+    case "member-expression":
+      return statics.has(expression) || resolvePropertyExtension(types.get(expression.object) ?? null, expression.property) !== null;
+    case "call-expression":
+      if (expression.method === null && expression.callee.kind === "identifier" && expression.callee.name === "super") {
+        return true;
+      }
+      return expression.callee.kind === "member-expression" && resolveCallExtension(types.get(expression.callee.object) ?? null, expression.callee.property) !== null;
+    default:
+      return false;
+  }
+}
+function holdsFunction(expression) {
+  return expression.kind === "function-expression" || children(expression).some(holdsFunction);
+}
+function collect2(input, expression, found) {
+  if (isPreservableExpression(expression, input.types, input.staticAccess)) {
+    return true;
+  }
+  if (isOwnFailure(expression, input.types, input.staticAccess)) {
+    found.push(expression);
+    return true;
+  }
+  return children(expression).every((child) => collect2(input, child, found));
+}
+function statementExpressions3(statement) {
+  switch (statement.kind) {
+    case "local-statement":
+      return [...statement.values];
+    case "assignment-statement":
+      return statement.operator === "=" ? [...statement.targets, ...statement.values] : null;
+    case "call-statement":
+      return [statement.expression];
+    case "return-statement":
+      return [...statement.values];
+    case "if-statement":
+      return statement.clauses.map((clause) => clause.condition);
+    default:
+      return null;
+  }
+}
+function expressionEdits(input, statement) {
+  const slots = input.development ? statementExpressions3(statement) : null;
+  if (slots === null) {
+    return null;
+  }
+  const found = [];
+  if (!slots.every((slot) => collect2(input, slot, found)) || found.length === 0) {
+    return null;
+  }
+  const edits = [];
+  for (const expression of found) {
+    const span = input.spans.get(expression);
+    if (span === void 0 || holdsFunction(expression)) {
+      return null;
+    }
+    const state = createEmitState(input.types, input.references, input.generatedMembers, input.staticAccess);
+    const replacement = emitExpression(state, expression);
+    if (replacement.includes("\n") || input.source.slice(span.start, span.end).includes("\n")) {
+      return null;
+    }
+    edits.push({ start: span.start, end: span.end, replacement });
+  }
+  return edits;
+}
+
 // ../compiler/src/emitter/preserve-loops.ts
 var BREAK_KEYWORD = "break";
 var CONTINUE_KEYWORD = "continue";
@@ -22263,8 +22374,11 @@ function visit(collector, statement, wrapped) {
     descend(collector, statement, false, surgical.wrapsBody);
     return;
   }
-  if (isPreservableStatement(statement, collector.input.types, collector.input.staticAccess) && keepsScaffolding(statement)) {
+  const preservable = isPreservableStatement(statement, collector.input.types, collector.input.staticAccess);
+  const narrowed = preservable ? null : expressionEdits(collector.input, statement);
+  if ((preservable || narrowed !== null) && keepsScaffolding(statement)) {
     const inherited = statement.kind === "do-statement" || statement.kind === "if-statement" ? wrapped : false;
+    collector.edits.push(...narrowed ?? []);
     descend(collector, statement, inherited, false);
     return;
   }

package/package.json

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