code-the-jewels 0.1.0

package/src/semantic.ts

@@ -0,0 +1,144 @@
+import { Program, Statement, Expression } from './ast';
+import { RTJError } from './diagnostics';
+
+const VALID_MODULES = ['bk:text', 'bk:parse', 'atl:data', 'atl:flow'];
+
+export class Semantic {
+  private scopes: Set<string>[] = [];
+
+  analyze(program: Program): void {
+    this.pushScope();
+    for (const stmt of program.body) {
+      this.analyzeStatement(stmt);
+    }
+    this.popScope();
+  }
+
+  private pushScope(): void {
+    this.scopes.push(new Set());
+  }
+
+  private popScope(): void {
+    this.scopes.pop();
+  }
+
+  private declare(name: string, line?: number): void {
+    const top = this.scopes[this.scopes.length - 1];
+    if (top.has(name)) {
+      throw new RTJError('NameError', `duplicate jewel '${name}'`, line);
+    }
+    top.add(name);
+  }
+
+  private lookup(name: string): boolean {
+    for (let i = this.scopes.length - 1; i >= 0; i--) {
+      if (this.scopes[i].has(name)) return true;
+    }
+    return false;
+  }
+
+  private analyzeStatement(stmt: Statement): void {
+    switch (stmt.type) {
+      case 'VarDecl':
+        this.analyzeExpression(stmt.init);
+        this.declare(stmt.name, stmt.loc.line);
+        break;
+      case 'FunctionDecl':
+        this.declare(stmt.name, stmt.loc.line);
+        this.pushScope();
+        for (const p of stmt.params) {
+          this.declare(p, stmt.loc.line);
+        }
+        for (const s of stmt.body.body) {
+          this.analyzeStatement(s);
+        }
+        this.popScope();
+        break;
+      case 'ReturnStmt':
+        if (stmt.value) this.analyzeExpression(stmt.value);
+        break;
+      case 'TalkStmt':
+        this.analyzeExpression(stmt.value);
+        break;
+      case 'IfStmt':
+        this.analyzeExpression(stmt.condition);
+        this.pushScope();
+        for (const s of stmt.consequent.body) this.analyzeStatement(s);
+        this.popScope();
+        if (stmt.alternate) {
+          this.pushScope();
+          for (const s of stmt.alternate.body) this.analyzeStatement(s);
+          this.popScope();
+        }
+        break;
+      case 'LoopStmt':
+        this.analyzeExpression(stmt.iterable);
+        this.pushScope();
+        this.declare(stmt.variable, stmt.loc.line);
+        for (const s of stmt.body.body) this.analyzeStatement(s);
+        this.popScope();
+        break;
+      case 'ImportStmt':
+        if (!VALID_MODULES.includes(stmt.source)) {
+          throw new RTJError('ImportError', `unknown feature source '${stmt.source}'`, stmt.loc.line);
+        }
+        for (const name of stmt.names) {
+          this.declare(name, stmt.loc.line);
+        }
+        break;
+      case 'ThrowStmt':
+        this.analyzeExpression(stmt.value);
+        break;
+      case 'ExpressionStmt':
+        this.analyzeExpression(stmt.expr);
+        break;
+      case 'BlockStmt':
+        this.pushScope();
+        for (const s of stmt.body) this.analyzeStatement(s);
+        this.popScope();
+        break;
+    }
+  }
+
+  private analyzeExpression(expr: Expression): void {
+    switch (expr.type) {
+      case 'Identifier':
+        // Warn but don't error in v0.1 (runtime may provide)
+        break;
+      case 'StringLiteral':
+      case 'NumberLiteral':
+      case 'BooleanLiteral':
+      case 'NullLiteral':
+        break;
+      case 'ArrayLiteral':
+        for (const el of expr.elements) this.analyzeExpression(el);
+        break;
+      case 'ObjectLiteral':
+        for (const pair of expr.pairs) this.analyzeExpression(pair.value);
+        break;
+      case 'BinaryExpr':
+        this.analyzeExpression(expr.left);
+        this.analyzeExpression(expr.right);
+        break;
+      case 'UnaryExpr':
+        this.analyzeExpression(expr.operand);
+        break;
+      case 'CallExpr':
+        this.analyzeExpression(expr.callee);
+        for (const arg of expr.args) this.analyzeExpression(arg);
+        break;
+      case 'MemberExpr':
+        this.analyzeExpression(expr.object);
+        if (expr.computed) this.analyzeExpression(expr.property);
+        break;
+      case 'PipeExpr':
+        for (const step of expr.steps) this.analyzeExpression(step);
+        break;
+      case 'DuoExpr':
+        this.analyzeExpression(expr.input);
+        for (const step of expr.mikePipeline) this.analyzeExpression(step);
+        for (const step of expr.elPipeline) this.analyzeExpression(step);
+        break;
+    }
+  }
+}

package/src/tests/basic.test.ts

@@ -0,0 +1,74 @@
+import { Lexer } from '../lexer';
+import { Parser } from '../parser';
+import { Semantic } from '../semantic';
+import { Generator } from '../generator';
+
+function compile(source: string): string {
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  const semantic = new Semantic();
+  semantic.analyze(ast);
+  const gen = new Generator();
+  return gen.generate(ast);
+}
+
+function test(name: string, fn: () => void): void {
+  try {
+    fn();
+    console.log(`PASS: ${name}`);
+  } catch (err) {
+    console.error(`FAIL: ${name}`);
+    console.error(err);
+    process.exitCode = 1;
+  }
+}
+
+function assert(condition: boolean, msg: string): void {
+  if (!condition) throw new Error(`Assertion failed: ${msg}`);
+}
+
+test('lexer tokenizes hello world', () => {
+  const lexer = new Lexer('talk "hello"');
+  const tokens = lexer.tokenize();
+  assert(tokens[0].type === 'TALK', 'first token is TALK');
+  assert(tokens[1].type === 'STRING', 'second token is STRING');
+  assert(tokens[1].value === 'hello', 'string value is hello');
+});
+
+test('parser creates TalkStmt', () => {
+  const lexer = new Lexer('talk "hello"');
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  assert(ast.body.length === 1, 'one statement');
+  assert(ast.body[0].type === 'TalkStmt', 'is TalkStmt');
+});
+
+test('generator outputs talk call', () => {
+  const js = compile('talk "hello"');
+  assert(js.includes('__rtj.talk("hello")'), 'contains talk call');
+});
+
+test('pipe expression compiles to nested calls', () => {
+  const js = compile('feature trim, upper from "bk:text"\njewel x = "hi" |> trim |> upper');
+  assert(js.includes('upper(trim("hi"))'), 'pipe flattened correctly');
+});
+
+test('duo expression compiles', () => {
+  const js = compile('feature trim from "bk:text"\nfeature words from "bk:parse"\nfeature count from "atl:data"\njewel x = duo("hi") {\n  mike: trim |> words\n  el: count\n}');
+  assert(js.includes('count(words(trim("hi")))'), 'duo flattened correctly');
+});
+
+test('semantic rejects invalid import source', () => {
+  let threw = false;
+  try {
+    compile('feature foo from "bk:audio"');
+  } catch (err) {
+    threw = true;
+  }
+  assert(threw, 'should throw on invalid import');
+});
+
+console.log('All tests complete.');

package/src/token.ts

@@ -0,0 +1,85 @@
+export enum TokenType {
+  // Keywords
+  JEWEL = 'JEWEL',
+  VERSE = 'VERSE',
+  SEND = 'SEND',
+  TALK = 'TALK',
+  IFWILD = 'IFWILD',
+  ELSEWILD = 'ELSEWILD',
+  RUN = 'RUN',
+  IN = 'IN',
+  FEATURE = 'FEATURE',
+  FROM = 'FROM',
+  YANK = 'YANK',
+  DUO = 'DUO',
+  MIKE = 'MIKE',
+  EL = 'EL',
+
+  // Literals
+  IDENTIFIER = 'IDENTIFIER',
+  STRING = 'STRING',
+  NUMBER = 'NUMBER',
+  BOOLEAN = 'BOOLEAN',
+  NULL = 'NULL',
+
+  // Operators
+  PIPE = 'PIPE',
+  PLUS = 'PLUS',
+  MINUS = 'MINUS',
+  STAR = 'STAR',
+  SLASH = 'SLASH',
+  PERCENT = 'PERCENT',
+  EQ_EQ = 'EQ_EQ',
+  BANG_EQ = 'BANG_EQ',
+  GT = 'GT',
+  LT = 'LT',
+  GT_EQ = 'GT_EQ',
+  LT_EQ = 'LT_EQ',
+  AND_AND = 'AND_AND',
+  OR_OR = 'OR_OR',
+  BANG = 'BANG',
+  ASSIGN = 'ASSIGN',
+
+  // Punctuation
+  LBRACE = 'LBRACE',
+  RBRACE = 'RBRACE',
+  LPAREN = 'LPAREN',
+  RPAREN = 'RPAREN',
+  LBRACKET = 'LBRACKET',
+  RBRACKET = 'RBRACKET',
+  COMMA = 'COMMA',
+  COLON = 'COLON',
+  DOT = 'DOT',
+  SEMICOLON = 'SEMICOLON',
+
+  // Special
+  NEWLINE = 'NEWLINE',
+  EOF = 'EOF',
+}
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  line: number;
+  column: number;
+}
+
+export const KEYWORDS: Record<string, TokenType> = {
+  jewel: TokenType.JEWEL,
+  verse: TokenType.VERSE,
+  send: TokenType.SEND,
+  talk: TokenType.TALK,
+  ifwild: TokenType.IFWILD,
+  elsewild: TokenType.ELSEWILD,
+  run: TokenType.RUN,
+  in: TokenType.IN,
+  feature: TokenType.FEATURE,
+  from: TokenType.FROM,
+  yank: TokenType.YANK,
+  duo: TokenType.DUO,
+  mike: TokenType.MIKE,
+  el: TokenType.EL,
+  true: TokenType.BOOLEAN,
+  false: TokenType.BOOLEAN,
+  null: TokenType.NULL,
+};

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "types": ["node"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}