naider 1.24.5 → 2.0.1

package/src/generator-c.js

@@ -8,6 +8,7 @@ export class CGenerator {
     this.typedefs = [];
     this.functions = [];
     this.mainBody = [];
+    this.variableTypes = new Map();
     this.sourceMap = [];
     this.currentSourceLine = 0;
     this.sourceFile = options.sourceFile || null;
@@ -252,9 +253,39 @@ export class CGenerator {
 
   visitTypedVar(node) {
     const type = node.varType ? this.mapType(node.varType) : this.inferCType(node.value);
+    this.variableTypes.set(node.name, type);
     this.emit(`${type} ${node.name} = ${this.expr(node.value)};`);
   }
 
+  formatSpecifierForType(type) {
+    if (type === 'int') return '%d';
+    if (type === 'double') return '%g';
+    if (type === 'const char*') return '%s';
+    return '%p';
+  }
+
+  formatSpecifierForExpression(node) {
+    if (!node) return '%p';
+    if (node.type === 'String' || node.type === 'InterpolatedString') return '%s';
+    if (node.type === 'Bool') return '%d';
+    if (node.type === 'Number') {
+      return Number.isInteger(Number(node.value)) ? '%d' : '%g';
+    }
+    if (node.type === 'Identifier') {
+      return this.formatSpecifierForType(this.variableTypes.get(node.name));
+    }
+    if (node.type === 'Binary') {
+      if (['==', '!=', '<', '<=', '>', '>=', '&&', '||'].includes(node.op)) {
+        return '%d';
+      }
+      return this.formatSpecifierForExpression(node.left) === '%g'
+        || this.formatSpecifierForExpression(node.right) === '%g'
+        ? '%g'
+        : '%d';
+    }
+    return '%p';
+  }
+
   inferCType(valueNode) {
     if (!valueNode) return 'void*';
     switch (valueNode.type) {
@@ -421,25 +452,14 @@ export class CGenerator {
   visitLog(node) {
     this.includes.add('<stdio.h>');
     const args = node.args.map(a => this.expr(a));
-    if (args.length === 1) {
-      const arg = args[0];
-      if (node.args[0] && node.args[0].type === 'String') {
-        this.emit(`printf(${arg});`);
-        this.emit(`printf("\\n");`);
-      } else {
-        this.emit(`printf("%s\\n", ${arg});`);
-      }
-    } else {
-      // Multiple args: print each separated by space
-      const fmtParts = args.map(() => '%s').join(' ');
-      this.emit(`printf("${fmtParts}\\n", ${args.join(', ')});`);
-    }
+    const format = node.args.map(arg => this.formatSpecifierForExpression(arg)).join(' ');
+    this.emit(`printf("${format}\\n", ${args.join(', ')});`);
   }
 
   visitThrow(node) {
     this.includes.add('<stdio.h>');
     this.includes.add('<stdlib.h>');
-    this.emit(`fprintf(stderr, "Error: %s\\n", ${this.expr(node.value)});`);
+    this.emit(`fprintf(stderr, "Error: ${this.formatSpecifierForExpression(node.value)}\\n", ${this.expr(node.value)});`);
     this.emit('exit(1);');
   }
 

package/src/generator-go.js

@@ -2,6 +2,7 @@ export class GoGenerator {
   constructor(options = {}) {
     this.indent = 0;
     this.output = [];
+    this.mainBody = [];
     this.imports = new Set();
     this.models = new Map();
     this.schemas = new Map();
@@ -16,6 +17,9 @@ export class GoGenerator {
 
   generate(ast) {
     this.visitProgram(ast);
+    this.output.push('func main() {');
+    this.output.push(...this.mainBody);
+    this.output.push('}');
 
     const preamble = ['package main', ''];
     if (this.imports.size > 0) {
@@ -46,8 +50,30 @@ export class GoGenerator {
   }
 
   visitProgram(node) {
+    const declarations = new Set([
+      'Use',
+      'UseDestructured',
+      'Function',
+      'TypedVar',
+      'Model',
+      'SchemaDecl',
+      'EnumDecl',
+      'ClassDecl',
+    ]);
+
     for (const stmt of node.body) {
+      if (declarations.has(stmt.type)) {
+        this.visitStatement(stmt);
+        continue;
+      }
+
+      const output = this.output;
+      const indent = this.indent;
+      this.output = this.mainBody;
+      this.indent = 1;
       this.visitStatement(stmt);
+      this.output = output;
+      this.indent = indent;
     }
   }
 

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() {