@ecoma-io/archkeep 0.16.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecoma-io/archkeep",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Architecture enforcement for polyglot repositories — dependency graphs and module boundaries for Go, Rust, Python, TypeScript, JavaScript, Vue, Java and Kotlin",
   "keywords": [
     "architecture",

package/src/analysis/csharp.mjs

@@ -70,6 +70,11 @@
  *   same class of limit Kotlin's backtick segments pin.
  * - An **unterminated directive** (no `;` before end of line) is not a
  *   complete directive and is not read.
+ * - A **statement whose initializer opens but never closes** (`using var x =
+ *   new F {`, the `;` never arriving) is neither read nor flagged — the `{`
+ *   behind the resource's `=` is the statement's own (#469), the same
+ *   silence a `using (r) {` block has always held. The malformation scan
+ *   judges directives only.
  */
 import { csharpNamespaceIndex } from "./dotnet/namespaces.mjs";
 import { maskCSharpComments } from "./dotnet/mask.mjs";
@@ -130,6 +135,13 @@ const CS_EXTERN_ALIAS = new RegExp(
 /** Exactly one identifier followed by `=`: the alias form. */
 const ALIAS_FORM = new RegExp(String.raw`^(${SEG})[ \t]*=[ \t]*(.+)$`, "su");
 
+/**
+ * One bare identifier, optionally verbatim (`@class`): an alias's own name.
+ * The malformation scan reads it backwards — the text before an initializer
+ * `=` is an alias's name only when it is NOT this shape.
+ */
+const ALIAS_NAME = new RegExp(String.raw`^@?${SEG}$`, "u");
+
 /** A dotted name, optionally behind the `global::` qualifier: the plain form. */
 const PLAIN_FORM = new RegExp(String.raw`^(?:global::)?(${DOTTED_NAME})$`, "u");
 
@@ -262,10 +274,17 @@ export function parseCSharpDirectiveSites(csharpText) {
  * from one the file truncates — a failed write, a merge marker left
  * mid-directive — which used to parse as zero directive sites with no
  * failure, byte-for-byte identical to a file that imports nothing (#419).
- * A `(` right after the
- * keyword is the using-STATEMENT family — `using (var s = f()) { … }`,
- * `using (x);`, and the `using var x = f();` declaration whose body starts
- * `var` — never a directive; a statement's `;` may arrive inside its own
+ * Statement shapes hold no opinion at all, by two markers the text shows
+ * before any terminator arrives: a `(` right after the keyword is the
+ * parenthesized family — `using (var s = f()) { … }`, `using (x);` — and an
+ * `=` between the keyword and the walk's first `{` is the declaration family
+ * (#469) whenever MORE than one bare identifier precedes it — `var writer`,
+ * `Dictionary<string, int> map`, every declaration spelling — because a
+ * brace behind a resource's own `=` is that statement's initializer, while
+ * the first `{` behind a directive can only be the file's truncation. One
+ * bare identifier before the `=` is an ALIAS's own name (`using Pair = …`),
+ * the brace then belongs to whatever follows, and the truncated alias stays
+ * loud. A statement's `;` may arrive inside its own
  * block, so the scan has no opinion there. One silence the rule keeps: a
  * missing `;` that a LATER declaration supplies its own (`extern alias X`
  * then `namespace Shop.App;`) is not seen — the walk reads the next
@@ -324,11 +343,21 @@ export function csharpDirectiveMalformations(csharpText) {
     if (source[at] === "(") continue;
     const next = usingTerminatorAfter(at);
     if (next === undefined || next[0] === "{") {
-      flag(
-        m.index + m[0].indexOf("using"),
-        "using",
-        "a `using` directive never reaches its `;` — the file is truncated or malformed, so its imports cannot be read",
-      );
+      // The declaration family's initializer `=` (#469) — argued beside the
+      // openers above: an `=` whose prefix is more than one bare identifier
+      // is a resource's own, and the brace with it. One bare identifier is
+      // an alias's own name, the brace belongs to whatever follows, and the
+      // truncated alias stays loud.
+      const eq = next !== undefined ? source.indexOf("=", at) : -1;
+      const initializer =
+        eq !== -1 && eq < next.index && !ALIAS_NAME.test(source.slice(at, eq).trim());
+      if (next === undefined || !initializer) {
+        flag(
+          m.index + m[0].indexOf("using"),
+          "using",
+          "a `using` directive never reaches its `;` — the file is truncated or malformed, so its imports cannot be read",
+        );
+      }
     }
   }
   const externTerminatorAfter = terminatorAfter();

package/src/analysis/go.mjs

@@ -44,6 +44,13 @@
  * quote closed on a later line, a `)` supplied from a function body below —
  * produce a record today and stay the documented parse limits above.
  *
+ * One misread answers neither record nor failure, named as a limit rather
+ * than fixed (#468's neighbourhood): a bare `import` whose line ends with
+ * no path and whose `(` arrives from the statement BELOW it — `import`
+ * alone, then `const (` opening the next — is read as that block, and the
+ * doubly-broken file stays silent. Rejecting it needs a same-line rule
+ * that would flag the legal `import` newline `"path"` continuation.
+ *
  * ## An unreadable go.mod refuses, it does not skip (#405)
  *
  * `parseGoModulePath` parses content; it never sees a failed read. Reading a
@@ -310,7 +317,14 @@ export function goImportMalformations(goText) {
   // close just found rather than rescanning the text before it.
   let lastClose = 0;
   let unclosedSince = -1;
-  for (const m of source.matchAll(/(?:^|;)[ \t]*import/gm)) {
+  // `import` must be the keyword, never a prefix of an identifier (#468): a
+  // const member named `importPath` sits at line head exactly where the
+  // keyword would, and reading it as the keyword flagged a compiling file
+  // "an import states no path". Go lexes by maximal munch — letters, digits,
+  // and `_` continuing the word make it one identifier — so the lookahead
+  // excludes exactly those, and every legal follower (`(`, a quote, an
+  // alias, whitespace) still opens.
+  for (const m of source.matchAll(/(?:^|;)[ \t]*import(?![\p{L}\p{Nd}_])/gmu)) {
     let at = m.index + m[0].length;
     while (at < source.length && /\s/u.test(source[at])) at += 1;
     if (at >= source.length) {