naider 1.24.5 → 2.0.0

package/src/generator.js

@@ -22,6 +22,10 @@ export class Generator {
   }
 
   generate(ast) {
+    for (const node of ast.body) {
+      if (node.type === 'SchemaDecl') this.schemas.set(node.name, node);
+    }
+
     this.visitProgram(ast);
 
     const preamble = [];
@@ -185,7 +189,7 @@ export class Generator {
   }
 
   rewriteNaideImport(source) {
-    return source.replace(/\.(naide|nx)(['"])/g, '.mjs$2');
+    return source.replace(/\.naide(['"])/g, '.mjs$1');
   }
 
   visitFunction(node) {

package/src/index.js

@@ -1,7 +1,6 @@
 import { Lexer } from './lexer.js';
 import { Parser } from './parser.js';
 import { Generator } from './generator.js';
-import { preprocess } from './preprocess.js';
 import { TypeChecker } from './typechecker.js';
 import { generate, generateProject, updateProject, expandDirectives } from './gen.js';
 
@@ -76,11 +75,35 @@ async function getGenerator(target, options) {
   }
 }
 
-export function compile(source, { mode = 'naide', runtimePath, sourceFile, typeCheck = false, target = 'node' } = {}) {
-  let processedSource = source;
-  if (mode === 'x') {
-    processedSource = preprocess(source);
+function resolveSchemaInheritance(ast) {
+  const schemas = new Map(ast.body.filter(node => node.type === 'SchemaDecl').map(node => [node.name, node]));
+  const resolved = new Map();
+  const resolving = new Set();
+
+  function resolveFields(schema) {
+    if (resolved.has(schema.name)) return resolved.get(schema.name);
+    if (resolving.has(schema.name)) {
+      throw new Error(`Circular schema inheritance involving '${schema.name}'`);
+    }
+
+    resolving.add(schema.name);
+    const parent = schema.parent ? schemas.get(schema.parent) : null;
+    const fields = new Map((parent ? resolveFields(parent) : []).map(field => [field.name, field]));
+    for (const field of schema.fields) fields.set(field.name, field);
+    const result = [...fields.values()];
+    resolving.delete(schema.name);
+    resolved.set(schema.name, result);
+    return result;
+  }
+
+  for (const schema of schemas.values()) {
+    schema.fields = resolveFields(schema);
   }
+  return ast;
+}
+
+export function compile(source, { runtimePath, sourceFile, typeCheck = false, target = 'node' } = {}) {
+  let processedSource = source;
   if (processedSource.includes('~~')) {
     processedSource = expandDirectives(processedSource).source;
   }
@@ -88,7 +111,7 @@ export function compile(source, { mode = 'naide', runtimePath, sourceFile, typeC
     const lexer = new Lexer(processedSource);
     const tokens = lexer.tokenize();
     const parser = new Parser(tokens);
-    const ast = parser.parse();
+    const ast = resolveSchemaInheritance(parser.parse());
 
     let typeErrors = null;
     if (typeCheck) {
@@ -98,7 +121,7 @@ export function compile(source, { mode = 'naide', runtimePath, sourceFile, typeC
 
     const generator = new Generator({ runtimePath, sourceFile });
     const js = generator.generate(ast);
-    return { js, ast, tokens, sourceMap: generator.sourceMap, naide: mode === 'x' ? processedSource : null, typeErrors };
+    return { js, ast, tokens, sourceMap: generator.sourceMap, typeErrors };
   } catch (e) {
     const lineMatch = e.message.match(/line (\d+)/);
     if (lineMatch) {
@@ -117,11 +140,8 @@ export function compile(source, { mode = 'naide', runtimePath, sourceFile, typeC
   }
 }
 
-export async function compileAsync(source, { mode = 'naide', runtimePath, sourceFile, typeCheck = false, target = 'node' } = {}) {
+export async function compileAsync(source, { runtimePath, sourceFile, typeCheck = false, target = 'node' } = {}) {
   let processedSource = source;
-  if (mode === 'x') {
-    processedSource = preprocess(source);
-  }
   if (processedSource.includes('~~')) {
     processedSource = expandDirectives(processedSource).source;
   }
@@ -129,7 +149,7 @@ export async function compileAsync(source, { mode = 'naide', runtimePath, source
     const lexer = new Lexer(processedSource);
     const tokens = lexer.tokenize();
     const parser = new Parser(tokens);
-    const ast = parser.parse();
+    const ast = resolveSchemaInheritance(parser.parse());
 
     let typeErrors = null;
     if (typeCheck) {
@@ -139,7 +159,7 @@ export async function compileAsync(source, { mode = 'naide', runtimePath, source
 
     const generator = await getGenerator(target, { runtimePath, sourceFile });
     const code = generator.generate(ast);
-    return { js: code, code, ast, tokens, sourceMap: generator.sourceMap, naide: mode === 'x' ? processedSource : null, typeErrors, target };
+    return { js: code, code, ast, tokens, sourceMap: generator.sourceMap, typeErrors, target };
   } catch (e) {
     const lineMatch = e.message.match(/line (\d+)/);
     if (lineMatch) {
@@ -162,4 +182,4 @@ export function transpile(source, opts) {
   return compile(source, opts).js;
 }
 
-export { preprocess, generate, generateProject, updateProject };
+export { generate, generateProject, updateProject };

package/src/parser.js

@@ -345,13 +345,13 @@ export class Parser {
 
     if (this.match(T.ASSIGN)) {
       const expr = this.parseExpression();
-      return new ASTNode('Function', { name, params, returnType, body: [new ASTNode('Return', { value: expr })], isAsync, isPublic });
+      return new ASTNode('Function', { name, params, returnType, body: [new ASTNode('Return', { value: expr }, tok.line)], isAsync, isPublic }, tok.line);
     }
 
     this.expect(T.COLON);
     const body = this.parseBlock();
 
-    return new ASTNode('Function', { name, params, returnType, body, isAsync, isPublic });
+    return new ASTNode('Function', { name, params, returnType, body, isAsync, isPublic }, tok.line);
   }
 
   parseFnParams() {
@@ -418,9 +418,9 @@ export class Parser {
   }
 
   parseReturn() {
-    this.advance(); // ret
+    const returnToken = this.advance(); // ret
     if (this.at(T.NEWLINE) || this.at(T.EOF) || this.at(T.DEDENT)) {
-      return new ASTNode('Return', { value: null });
+      return new ASTNode('Return', { value: null }, returnToken.line);
     }
     if (this.match(T.DOT)) {
       const method = this.expect(T.IDENT).value;
@@ -457,7 +457,7 @@ export class Parser {
       return new ASTNode('ReturnMethod', { method, value });
     }
     const value = this.parseExpression();
-    return new ASTNode('Return', { value });
+    return new ASTNode('Return', { value }, returnToken.line);
   }
 
   expectIdentLike() {
@@ -467,7 +467,8 @@ export class Parser {
   }
 
   parseTypedVariable() {
-    const varType = this.advance().value;
+    const typeToken = this.advance();
+    const varType = typeToken.value;
     if (this.at(T.LBRACE)) {
       return this.parseDestructure(varType, false);
     }
@@ -477,11 +478,11 @@ export class Parser {
     const name = this.expectIdentLike();
     this.expect(T.ASSIGN);
     const value = this.parseExpression();
-    return new ASTNode('TypedVar', { varType, name, value, isMut: false, isPublic: false });
+    return new ASTNode('TypedVar', { varType, name, value, isMut: false, isPublic: false }, typeToken.line);
   }
 
   parseMutVariable() {
-    this.advance(); // mut
+    const mutToken = this.advance(); // mut
     if (TYPE_TOKENS.has(this.peek().type)) {
       const node = this.parseTypedVariable();
       node.isMut = true;
@@ -493,7 +494,7 @@ export class Parser {
     const name = this.expectIdentLike();
     this.expect(T.ASSIGN);
     const value = this.parseExpression();
-    return new ASTNode('TypedVar', { varType: null, name, value, isMut: true });
+    return new ASTNode('TypedVar', { varType: null, name, value, isMut: true }, mutToken.line);
   }
 
   parseDestructure(varType, isMut) {
@@ -865,8 +866,7 @@ export class Parser {
     const name = this.expect(T.IDENT).value;
 
     let parent = null;
-    if (this.at(T.IDENT) && this.peek().value === 'extends') {
-      this.advance();
+    if (this.match(T.EXTENDS)) {
       parent = this.expect(T.IDENT).value;
     }
 
@@ -1161,10 +1161,11 @@ export class Parser {
         const prop = this.expectPropertyName();
         expr = new ASTNode('OptionalAccess', { object: expr, property: prop });
       } else if (this.at(T.LPAREN)) {
+        const callLine = this.peek().line;
         this.advance();
         const args = this.parseArgList();
         this.expect(T.RPAREN);
-        expr = new ASTNode('Call', { callee: expr, args });
+        expr = new ASTNode('Call', { callee: expr, args }, callLine);
       } else if (this.at(T.LBRACKET)) {
         this.advance();
         const index = this.parseExpression();
@@ -1466,10 +1467,10 @@ export class Parser {
     }
     this.match(T.DEDENT);
 
-    if (parent || methods.length > 0 || init) {
+    if (methods.length > 0 || init) {
       return new ASTNode('ClassDecl', { name, parent, fields, methods, init });
     }
-    return new ASTNode('SchemaDecl', { name, fields });
+    return new ASTNode('SchemaDecl', { name, parent, fields });
   }
 
   parseSchemaField() {

package/src/typechecker.js

@@ -4,6 +4,7 @@ export class TypeChecker {
     this.errors = [];
     this.warnings = [];
     this.functions = new Map();
+    this.returnTypes = [];
   }
 
   pushScope() { this.scopes.push(new Map()); }
@@ -29,10 +30,21 @@ export class TypeChecker {
   }
 
   check(ast) {
+    for (const stmt of ast.body) {
+      if (stmt.type === 'Function') this.registerFunction(stmt);
+    }
     this.visitProgram(ast);
     return { errors: this.errors, warnings: this.warnings };
   }
 
+  registerFunction(node) {
+    this.functions.set(node.name, {
+      params: node.params.map(p => ({ name: p.name, type: p.type || 'any', hasDefault: p.defaultValue !== null, spread: p.spread })),
+      returnType: node.returnType || 'any',
+      isAsync: node.isAsync || false,
+    });
+  }
+
   visitProgram(node) {
     for (const stmt of node.body) {
       this.visitStatement(stmt);
@@ -80,26 +92,19 @@ export class TypeChecker {
   }
 
   visitFunction(node, line) {
-    const paramTypes = {};
-    for (const p of node.params) {
-      paramTypes[p.name] = p.varType || 'any';
-    }
-
-    this.functions.set(node.name, {
-      params: node.params.map(p => ({ name: p.name, type: p.varType || 'any' })),
-      returnType: node.returnType || 'any',
-      isAsync: node.isAsync || false,
-    });
+    this.registerFunction(node);
 
     this.setType(node.name, 'function');
 
     this.pushScope();
     for (const p of node.params) {
-      this.setType(p.name, p.varType || 'any');
+      this.setType(p.name, p.type || 'any');
     }
+    this.returnTypes.push(node.returnType || 'any');
     for (const stmt of node.body) {
       this.visitStatement(stmt);
     }
+    this.returnTypes.pop();
     this.popScope();
   }
 
@@ -118,7 +123,22 @@ export class TypeChecker {
     }
   }
 
-  visitReturn(node, line) {}
+  visitReturn(node, line) {
+    const expectedType = this.returnTypes[this.returnTypes.length - 1];
+    if (!expectedType || expectedType === 'any') return;
+
+    if (!node.value) {
+      if (expectedType !== 'void') {
+        this.error(`Return type mismatch: expected ${expectedType} but got void`, line);
+      }
+      return;
+    }
+
+    const actualType = this.inferType(node.value);
+    if (actualType !== 'any' && !this.typesCompatible(expectedType, actualType)) {
+      this.error(`Return type mismatch: expected ${expectedType} but got ${actualType}`, line);
+    }
+  }
 
   visitIf(node, line) {
     this.visitBlock(node.body, line);
@@ -220,7 +240,10 @@ export class TypeChecker {
   inferCallType(node) {
     if (node.callee.type === 'Identifier') {
       const fn = this.functions.get(node.callee.name);
-      if (fn) return fn.returnType;
+      if (fn) {
+        this.checkCallArguments(node, fn);
+        return fn.returnType;
+      }
 
       const builtins = {
         'uuid': 'str', 'hash': 'str', 'verify': 'bool',
@@ -251,6 +274,30 @@ export class TypeChecker {
     return 'any';
   }
 
+  checkCallArguments(node, fn) {
+    const params = fn.params;
+    const line = node._line || 0;
+    const requiredCount = params.filter(p => !p.hasDefault && !p.spread).length;
+    const hasSpread = params.some(p => p.spread);
+
+    if (node.args.length < requiredCount || (!hasSpread && node.args.length > params.length)) {
+      const expected = hasSpread ? `at least ${requiredCount}` : `${requiredCount}${params.length === requiredCount ? '' : ` to ${params.length}`}`;
+      this.error(`Argument count mismatch for '${node.callee.name}': expected ${expected}, got ${node.args.length}`, line);
+    }
+
+    const spreadIndex = params.findIndex(param => param.spread);
+    for (let i = 0; i < node.args.length; i++) {
+      const paramIndex = spreadIndex >= 0 && i >= spreadIndex ? spreadIndex : i;
+      const param = params[paramIndex];
+      if (!param) continue;
+      const expectedType = param.type;
+      const actualType = this.inferType(node.args[i]);
+      if (expectedType !== 'any' && actualType !== 'any' && !this.typesCompatible(expectedType, actualType)) {
+        this.error(`Argument '${param.name}' of '${node.callee.name}' expects ${expectedType} but got ${actualType}`, line);
+      }
+    }
+  }
+
   typesCompatible(declared, actual) {
     if (declared === actual) return true;
     if (declared === 'any' || actual === 'any') return true;

package/vscode-naide/README.md

@@ -1,22 +1,20 @@
 # NAIDE Language Support for VS Code
 
-Syntax highlighting and language support for **NAIDE** (`.naide`) and **NAIDE-X** (`.nx`) files.
+Syntax highlighting and language support for **NAIDE** (`.naide`) files.
 
 ## Features
 
 - Syntax highlighting for all NAIDE keywords, types, and operators
-- Syntax highlighting for NAIDE-X shorthand prefixes (`>`, `?`, `!`, `$`, `^`, `@`, etc.)
 - String interpolation highlighting (`"Hello {name}"`)
 - Auto-indentation for block structures
 - Bracket matching and auto-closing
-- Comment toggling (`#` for .naide, `--` for .nx)
+- Comment toggling (`#`)
 
 ## File Associations
 
 | Extension | Language |
 |-----------|----------|
 | `.naide`  | NAIDE    |
-| `.nx`     | NAIDE-X  |
 
 ## Install
 
@@ -26,7 +24,7 @@ Syntax highlighting and language support for **NAIDE** (`.naide`) and **NAIDE-X*
 cd vscode-naide
 npm install -g @vscode/vsce
 vsce package
-code --install-extension naide-lang-1.0.0.vsix
+code --install-extension naide-lang-2.0.0.vsix
 ```
 
 ### Manual
@@ -35,4 +33,4 @@ Copy `vscode-naide/` to `~/.vscode/extensions/naide-lang/` and restart VS Code.
 
 ## About NAIDE
 
-NAIDE is an AI-optimized programming language that transpiles to Node.js. See [github.com/irxk/naide](https://github.com/irxk/naide).
+NAIDE is a programming language with one readable syntax, built-in diagnostics, and compiler targets. See [github.com/irxk/naide](https://github.com/irxk/naide).

package/vscode-naide/extension.js

@@ -18,10 +18,9 @@ function activate(context) {
   const clientOptions = {
     documentSelector: [
       { scheme: 'file', language: 'naide' },
-      { scheme: 'file', language: 'naidex' },
     ],
     synchronize: {
-      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.{naide,nx}'),
+      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.naide'),
     },
   };
 

package/vscode-naide/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "naide-lang",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "naide-lang",
-      "version": "1.1.0",
+      "version": "2.0.0",
       "dependencies": {
         "vscode-languageclient": "^9.0.0"
       },

package/vscode-naide/package.json

@@ -1,15 +1,14 @@
 {
   "name": "naide-lang",
   "displayName": "NAIDE Language",
-  "description": "Syntax highlighting, diagnostics, and autocomplete for NAIDE (.naide) and NAIDE-X (.nx)",
-  "version": "1.1.0",
+  "description": "Syntax highlighting, diagnostics, and autocomplete for NAIDE (.naide)",
+  "version": "2.0.0",
   "publisher": "irxk",
   "engines": { "vscode": "^1.75.0" },
   "categories": ["Programming Languages"],
   "main": "./extension.js",
   "activationEvents": [
-    "onLanguage:naide",
-    "onLanguage:naidex"
+    "onLanguage:naide"
   ],
   "repository": {
     "type": "git",
@@ -22,12 +21,6 @@
         "aliases": ["NAIDE", "naide"],
         "extensions": [".naide"],
         "configuration": "./language-configuration-naide.json"
-      },
-      {
-        "id": "naidex",
-        "aliases": ["NAIDE-X", "naidex", "nx"],
-        "extensions": [".nx"],
-        "configuration": "./language-configuration-nx.json"
       }
     ],
     "grammars": [
@@ -35,11 +28,6 @@
         "language": "naide",
         "scopeName": "source.naide",
         "path": "./syntaxes/naide.tmLanguage.json"
-      },
-      {
-        "language": "naidex",
-        "scopeName": "source.naidex",
-        "path": "./syntaxes/naidex.tmLanguage.json"
       }
     ],
     "configuration": {