@jhlagado/azm 0.2.11 → 0.2.12

package/dist/src/assembly/import-visibility.js

@@ -1,14 +1,22 @@
 import { diagnostic } from '../semantics/diagnostics.js';
 export function validateImportVisibility(items, diagnostics) {
-    const labels = collectLabelVisibility(items);
+    const symbols = collectSymbolVisibility(items);
     for (const item of items) {
-        validateItemReferences(item, labels, diagnostics);
+        validateItemReferences(item, symbols, diagnostics);
     }
 }
-function collectLabelVisibility(items) {
+function collectSymbolVisibility(items) {
     const labels = new Map();
+    const exactSymbols = new Set();
     const importedSourceUnits = importedUnitNames(items);
+    const symbolConflicts = buildSymbolConflictIndex(items);
     for (const item of items) {
+        for (const name of exactSymbolNames(item)) {
+            exactSymbols.add(name);
+        }
+    }
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
         if (item.kind !== 'label')
             continue;
         labels.set(item.name, {
@@ -16,14 +24,75 @@ function collectLabelVisibility(items) {
             definingSourceUnit: item.span.sourceUnit,
             definingSourceName: item.span.sourceName,
             public: isPublicLabel(item, importedSourceUnits),
+            duplicateName: hasAddressPlanningNameConflict(item.name, symbolConflicts, items, index),
         });
     }
-    return labels;
+    return { labels, exactSymbols };
+}
+function buildSymbolConflictIndex(items) {
+    const exact = new Map();
+    const declarationLower = new Map();
+    for (const item of items) {
+        for (const name of exactSymbolNames(item)) {
+            exact.set(name, (exact.get(name) ?? 0) + 1);
+        }
+        const declarationName = caseInsensitiveDeclarationName(item);
+        if (declarationName !== undefined) {
+            const key = declarationName.toLowerCase();
+            declarationLower.set(key, (declarationLower.get(key) ?? 0) + 1);
+        }
+    }
+    return { exact, declarationLower };
+}
+function hasAddressPlanningNameConflict(labelName, conflicts, items, labelIndex) {
+    return ((conflicts.exact.get(labelName) ?? 0) > 1 ||
+        (conflicts.declarationLower.get(labelName.toLowerCase()) ?? 0) > 0 ||
+        hasReportedEnumMemberConflict(labelName, items, labelIndex));
+}
+function hasReportedEnumMemberConflict(labelName, items, labelIndex) {
+    const lowerName = labelName.toLowerCase();
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (item.kind !== 'enum')
+            continue;
+        for (const memberName of qualifiedEnumMemberNames(item)) {
+            if (memberName === labelName)
+                return true;
+            if (index > labelIndex && memberName.toLowerCase() === lowerName)
+                return true;
+        }
+    }
+    return false;
+}
+function exactSymbolNames(item) {
+    switch (item.kind) {
+        case 'label':
+        case 'equ':
+            return [item.name];
+        case 'enum':
+            return qualifiedEnumMemberNames(item);
+        default:
+            return [];
+    }
+}
+function qualifiedEnumMemberNames(item) {
+    return item.kind === 'enum' ? item.members.map((member) => `${item.name}.${member}`) : [];
+}
+function caseInsensitiveDeclarationName(item) {
+    switch (item.kind) {
+        case 'enum':
+        case 'type':
+        case 'type-alias':
+            return item.name;
+        default:
+            return undefined;
+    }
 }
 function importedUnitNames(items) {
     const units = new Set();
     for (const item of items) {
-        if (item.span.sourceRelation === 'import' && item.span.sourceUnit !== undefined) {
+        if (item.span.sourceUnitRelation === 'import' &&
+            item.span.sourceUnit !== undefined) {
             units.add(item.span.sourceUnit);
         }
     }
@@ -34,39 +103,39 @@ function isPublicLabel(item, importedSourceUnits) {
         item.span.sourceUnit === undefined ||
         !importedSourceUnits.has(item.span.sourceUnit));
 }
-function validateItemReferences(item, labels, diagnostics) {
+function validateItemReferences(item, symbols, diagnostics) {
     switch (item.kind) {
         case 'org':
-            validateExpression(item.expression, item.span, labels, diagnostics);
+            validateExpression(item.expression, item.span, symbols, diagnostics);
             return;
         case 'equ':
-            validateExpression(item.expression, item.span, labels, diagnostics);
+            validateExpression(item.expression, item.span, symbols, diagnostics);
             return;
         case 'db':
             for (const value of item.values) {
-                validateDataValue(value, item.span, labels, diagnostics);
+                validateDataValue(value, item.span, symbols, diagnostics);
             }
             return;
         case 'dw':
             for (const value of item.values) {
-                validateExpression(value, item.span, labels, diagnostics);
+                validateExpression(value, item.span, symbols, diagnostics);
             }
             return;
         case 'ds':
-            validateExpression(item.size, item.span, labels, diagnostics);
+            validateExpression(item.size, item.span, symbols, diagnostics);
             if (item.fill !== undefined) {
-                validateExpression(item.fill, item.span, labels, diagnostics);
+                validateExpression(item.fill, item.span, symbols, diagnostics);
             }
             return;
         case 'align':
-            validateExpression(item.alignment, item.span, labels, diagnostics);
+            validateExpression(item.alignment, item.span, symbols, diagnostics);
             return;
         case 'binfrom':
         case 'binto':
-            validateExpression(item.expression, item.span, labels, diagnostics);
+            validateExpression(item.expression, item.span, symbols, diagnostics);
             return;
         case 'instruction':
-            validateInstruction(item.instruction, item.span, labels, diagnostics);
+            validateInstruction(item.instruction, item.span, symbols, diagnostics);
             return;
         case 'label':
         case 'comment':
@@ -78,14 +147,14 @@ function validateItemReferences(item, labels, diagnostics) {
             return;
     }
 }
-function validateDataValue(value, span, labels, diagnostics) {
+function validateDataValue(value, span, symbols, diagnostics) {
     if ('kind' in value && value.kind === 'string-fragment')
         return;
-    validateExpression(value, span, labels, diagnostics);
+    validateExpression(value, span, symbols, diagnostics);
 }
-function validateInstruction(instruction, span, labels, diagnostics) {
+function validateInstruction(instruction, span, symbols, diagnostics) {
     for (const expression of instructionExpressions(instruction)) {
-        validateExpression(expression, span, labels, diagnostics);
+        validateExpression(expression, span, symbols, diagnostics);
     }
 }
 function instructionExpressions(instruction) {
@@ -154,49 +223,55 @@ function operandExpressions(operand) {
             return [];
     }
 }
-function validateExpression(expression, span, labels, diagnostics) {
+function validateExpression(expression, span, symbols, diagnostics) {
     switch (expression.kind) {
         case 'symbol':
-            validateSymbolReference(expression.name, span, labels, diagnostics);
+            validateSymbolReference(expression.name, span, symbols, diagnostics);
             return;
         case 'byte-function':
         case 'unary':
-            validateExpression(expression.expression, span, labels, diagnostics);
+            validateExpression(expression.expression, span, symbols, diagnostics);
             return;
         case 'binary':
-            validateExpression(expression.left, span, labels, diagnostics);
-            validateExpression(expression.right, span, labels, diagnostics);
+            validateExpression(expression.left, span, symbols, diagnostics);
+            validateExpression(expression.right, span, symbols, diagnostics);
             return;
         case 'layout-cast':
-            validateExpression(expression.base, span, labels, diagnostics);
+            validateExpression(expression.base, span, symbols, diagnostics);
             for (const part of expression.path) {
                 if (part.kind === 'index') {
-                    validateExpression(part.expression, span, labels, diagnostics);
+                    validateExpression(part.expression, span, symbols, diagnostics);
                 }
             }
             return;
         case 'number':
         case 'current-location':
-        case 'type-size':
         case 'sizeof':
         case 'offset':
             return;
+        case 'type-size':
+            if (expression.typeExpr.length === undefined) {
+                validateSymbolReference(expression.typeExpr.name, span, symbols, diagnostics);
+            }
+            return;
     }
 }
-function validateSymbolReference(name, referenceSpan, labels, diagnostics) {
-    const label = lookupLabel(labels, name);
-    if (!label || label.public)
+function validateSymbolReference(name, referenceSpan, symbols, diagnostics) {
+    const label = lookupLabel(symbols, name);
+    if (!label || label.duplicateName || label.public)
         return;
     if (referenceSpan.sourceUnit === label.definingSourceUnit)
         return;
     diagnostics.push(diagnostic(referenceSpan, `symbol "${name}" is private to ${label.definingSourceName}; export it with @${label.name} or keep the reference inside that file`));
 }
-function lookupLabel(labels, name) {
-    const direct = labels.get(name);
+function lookupLabel(symbols, name) {
+    const direct = symbols.labels.get(name);
     if (direct)
         return direct;
+    if (symbols.exactSymbols.has(name))
+        return undefined;
     const lowerName = name.toLowerCase();
-    for (const [key, label] of labels) {
+    for (const [key, label] of symbols.labels) {
         if (key.toLowerCase() === lowerName)
             return label;
     }

package/dist/src/core/compile.js

@@ -158,6 +158,7 @@ function spanAt(line, column) {
         column,
         ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
         ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+        ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
     };
 }
 function firstColumn(text) {

package/dist/src/expansion/op-expand-selected.js

@@ -60,7 +60,14 @@ function expandTemplateItem(ops, item, bindings, line, diagnostics, overload, ex
 }
 function opEmittedSource(line) {
     return {
-        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        span: {
+            sourceName: line.sourceName,
+            line: line.line,
+            column: firstColumn(line.text),
+            ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+            ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+            ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
+        },
         kind: 'macro',
     };
 }

package/dist/src/expansion/op-expansion.d.ts

@@ -6,6 +6,9 @@ export type LogicalLineLike = {
     readonly sourceName: string;
     readonly line: number;
     readonly text: string;
+    readonly sourceUnit?: string;
+    readonly sourceRelation?: 'entry' | 'include' | 'import';
+    readonly sourceUnitRelation?: 'entry' | 'include' | 'import';
 };
 interface OpParam {
     readonly name: string;

package/dist/src/node/source-host.js

@@ -30,6 +30,7 @@ export async function expandSourceForTooling(options) {
         sourceStack: [],
         sourceUnit: entryFile,
         sourceRelation: 'entry',
+        sourceUnitRelation: 'entry',
         ...(options.preloadedText !== undefined ? { preloadedText: options.preloadedText } : {}),
         ...(options.signal !== undefined ? { signal: options.signal } : {}),
     });
@@ -60,7 +61,7 @@ async function expandFile(options) {
         recordLineComment(options.sourceLineComments, line);
         const directive = parseSourceLoadDirective(line.text);
         if (!directive) {
-            output.push(withSourceOwnership(line, options.sourceUnit, options.sourceRelation));
+            output.push(withSourceOwnership(line, options.sourceUnit, options.sourceRelation, options.sourceUnitRelation));
             continue;
         }
         const result = await resolveSourcePath(sourcePath, directive.path, options.includeDirs);
@@ -88,6 +89,7 @@ async function expandFile(options) {
             sourceStack: [...options.sourceStack, { sourcePath }],
             sourceUnit: directive.kind === 'import' ? result.resolved : options.sourceUnit,
             sourceRelation: directive.kind,
+            sourceUnitRelation: directive.kind === 'import' ? 'import' : options.sourceUnitRelation,
         });
         if (included !== undefined) {
             output.push(...included);
@@ -95,11 +97,12 @@ async function expandFile(options) {
     }
     return output;
 }
-function withSourceOwnership(line, sourceUnit, sourceRelation) {
+function withSourceOwnership(line, sourceUnit, sourceRelation, sourceUnitRelation) {
     return {
         ...line,
         sourceUnit,
         sourceRelation,
+        sourceUnitRelation,
     };
 }
 function recordLineComment(comments, line) {

package/dist/src/source/logical-lines.d.ts

@@ -5,6 +5,7 @@ export interface LogicalLine {
     readonly text: string;
     readonly sourceUnit?: string;
     readonly sourceRelation?: SourceRelation;
+    readonly sourceUnitRelation?: SourceRelation;
 }
 export type SourceRelation = 'entry' | 'include' | 'import';
 export declare function scanLogicalLines(source: SourceFile): LogicalLine[];

package/dist/src/source/source-span.d.ts

@@ -4,4 +4,5 @@ export interface SourceSpan {
     readonly column: number;
     readonly sourceUnit?: string;
     readonly sourceRelation?: 'entry' | 'include' | 'import';
+    readonly sourceUnitRelation?: 'entry' | 'include' | 'import';
 }

package/dist/src/syntax/parse-layout-declarations.js

@@ -112,6 +112,7 @@ function spanForLine(line) {
         column: firstNonWhitespaceColumn(line.text),
         ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
         ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+        ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
     };
 }
 function skipToLayoutEnd(lines, index, directive) {

package/dist/src/syntax/parse-line.js

@@ -127,5 +127,6 @@ function spanForLine(line) {
         column: firstNonWhitespaceColumn(line.text),
         ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
         ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+        ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhlagado/azm",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "AZM assembler for the Z80 family (Node.js CLI)",
   "license": "GPL-3.0-only",
   "engines": {