infornoid 0.2.0

data/lib/parser.rb

@@ -0,0 +1,273 @@
+#coding:utf-8
+# infornoid 递归下降语法分析器 — 确定性前端
+# 零依赖, 手写 Parser, AST 为 Ruby Hash
+# CALL: Parser.parse(tokens) → AST Hash
+# RETN: {type:"Program", body:[...]}
+
+module Infor
+  module Parser
+    module_function
+
+    def parse ts
+      @ts = ts
+      @i  = 0
+      prog = { type:'Program', body:[] }
+      while !at?(:EOF)
+        node = parse_decl
+        node and prog[:body] << node
+      end
+      prog
+    end
+
+    #### 前瞻 / 消费 ####
+
+    def cur; @ts[@i]; end
+    def nxt; @ts[@i+1]; end
+    def at? tt; cur && cur[:t] == tt; end
+
+    # eat: 无参 → 消费当前 token 并返回; 有参 → 校验类型后消费
+    def eat tt = nil
+      tk = cur
+      return nil unless tk
+      if tt && tk[:t] != tt
+        err "expected %s but got %s '%s'"%[tt, tk[:t], tk[:v]], tk
+        return nil
+      end
+      @i += 1
+      tk
+    end
+
+    #消费当前 token 并返回其 value
+    def eatv
+      tk = eat
+      tk ? tk[:v] : nil
+    end
+
+    def err msg, tk
+      $stderr.puts "[parse error] line %d col %d: %s"%[tk[:l], tk[:c], msg]
+    end
+
+    #### 声明 ####
+
+    def parse_decl
+      return parse_let  if at? :LET
+      return parse_fn   if at? :FN
+      parse_stmt
+    end
+
+    def parse_let
+      tk = eat :LET
+      id = eat :IDT
+      vt = nil
+      if at? :COL
+        eat :COL
+        vt = eatv
+      end
+      eat :ASN
+      val = parse_expr
+      eat :SCL
+      { type:'LetDecl', name:(id && id[:v]), varType:vt, value:val, line:(tk[:l]) }
+    end
+
+    def parse_fn
+      tk = eat :FN
+      id = eat :IDT
+      eat :LPR
+      params = []
+      while !at?(:RPR) && !at?(:EOF)
+        p = eat :IDT
+        eat :COL
+        pt = eatv
+        params << { name:(p[:v]), type:pt } rescue nil
+        eat :CMA if at? :CMA
+      end
+      eat :RPR
+      rt = nil
+      if at? :ARR
+        eat :ARR
+        rt = eatv
+      end
+      body = parse_block
+      { type:'FnDecl', name:(id[:v]), params:params, retType:rt, body:body, line:(tk[:l]) }
+    end
+
+    #### 语句 ####
+
+    def parse_stmt
+      return parse_let     if at? :LET
+      return parse_if      if at? :IF
+      return parse_while   if at? :WHL
+      return parse_return  if at? :RTN
+      return parse_block   if at? :LBR
+      # 表达式语句
+      e = parse_expr
+      eat :SCL
+      { type:'ExprStmt', expr:e, line:(e && e[:line]) }
+    end
+
+    def parse_block
+      tk = eat :LBR
+      stmts = []
+      while !at?(:RBR) && !at?(:EOF)
+        stmts << parse_stmt
+      end
+      eat :RBR
+      { type:'Block', body:stmts, line:(tk[:l]) }
+    end
+
+    def parse_if
+      tk = eat :IF
+      eat :LPR
+      cond = parse_expr
+      eat :RPR
+      then_blk = parse_block
+      else_blk = nil
+      if at? :ELS
+        eat :ELS
+        else_blk = parse_block
+      end
+      { type:'IfStmt', cond:cond, then:then_blk, els:else_blk, line:(tk[:l]) }
+    end
+
+    def parse_while
+      tk = eat :WHL
+      eat :LPR
+      cond = parse_expr
+      eat :RPR
+      body = parse_block
+      { type:'WhileStmt', cond:cond, body:body, line:(tk[:l]) }
+    end
+
+    def parse_return
+      tk = eat :RTN
+      val = nil
+      val = parse_expr unless at?(:SCL)
+      eat :SCL
+      { type:'ReturnStmt', value:val, line:(tk[:l]) }
+    end
+
+    #### 表达式: 优先级递降链 ####
+
+    def parse_expr; parse_assign; end
+
+    def parse_assign
+      left = parse_or
+      if at?(:ASN) && left && left[:type] == 'Ident'
+        eat :ASN
+        right = parse_assign
+        return { type:'Assign', target:left, value:right, line:left[:line] }
+      end
+      left
+    end
+
+    def parse_or
+      left = parse_and
+      while at? :OR
+        eat; right = parse_and
+        left = mkbin('||', left, right)
+      end
+      left
+    end
+
+    def parse_and
+      left = parse_eq
+      while at? :AND
+        eat; right = parse_eq
+        left = mkbin('&&', left, right)
+      end
+      left
+    end
+
+    def parse_eq
+      left = parse_cmp
+      while at?(:EQ) || at?(:NE)
+        op = eatv; right = parse_cmp
+        left = mkbin(op, left, right)
+      end
+      left
+    end
+
+    def parse_cmp
+      left = parse_add
+      while at?(:LT) || at?(:GT) || at?(:LE) || at?(:GE)
+        op = eatv; right = parse_add
+        left = mkbin(op, left, right)
+      end
+      left
+    end
+
+    def parse_add
+      left = parse_mul
+      while at?(:ADD) || at?(:SUB)
+        op = eatv; right = parse_mul
+        left = mkbin(op, left, right)
+      end
+      left
+    end
+
+    def parse_mul
+      left = parse_unary
+      while at?(:MUL) || at?(:DIV) || at?(:MOD)
+        op = eatv; right = parse_unary
+        left = mkbin(op, left, right)
+      end
+      left
+    end
+
+    def parse_unary
+      if at?(:NOT) || at?(:SUB)
+        op = eatv; operand = parse_unary
+        return { type:'Unary', op:op, operand:operand, line:(operand[:line]) }
+      end
+      parse_primary
+    end
+
+    def parse_primary
+      tk = cur
+      return { type:'Error', line:1 } unless tk
+      case tk[:t]
+      when :NUM
+        eat
+        { type:'NumLit', value:tk[:v], line:tk[:l] }
+      when :STR
+        eat
+        { type:'StrLit', value:tk[:v], line:tk[:l] }
+      when :TRU
+        eat
+        { type:'BoolLit', value:true, line:tk[:l] }
+      when :FLS
+        eat
+        { type:'BoolLit', value:false, line:tk[:l] }
+      when :IDT
+        eat
+        if at? :LPR
+          eat :LPR
+          args = []
+          while !at?(:RPR) && !at?(:EOF)
+            args << parse_expr
+            eat :CMA if at? :CMA
+          end
+          eat :RPR
+          { type:'Call', name:tk[:v], args:args, line:tk[:l] }
+        else
+          { type:'Ident', name:tk[:v], line:tk[:l] }
+        end
+      when :LPR
+        eat :LPR
+        e = parse_expr
+        eat :RPR
+        e
+      else
+        err "unexpected token %s '%s'"%[tk[:t], tk[:v]], tk
+        eat
+        { type:'Error', line:tk[:l] }
+      end
+    end
+
+    #构造二元表达式节点
+    def mkbin op, l, r
+      { type:'Binary', op:op, left:l, right:r, line:(l[:line]) }
+    end
+
+  end
+end

data/lib/semantic.rb

@@ -0,0 +1,214 @@
+#coding:utf-8
+# infornoid 语义分析 — 确定性规则引擎为主, LLM 顾问辅助
+# 零第三方依赖, 符号表 + 作用域 + 类型推导
+# CALL: Semantic.analyze(ast) → {ast, errors, types}
+# 设计: 规则引擎做确定性推导, LLM 只在规则未覆盖时给建议
+
+module Infor
+  module Semantic
+    module_function
+
+    #### 类型规则表 ####
+
+    # (leftType, op, rightType) → resultType
+    RULES = {
+      ['Number','+','Number']=>'Number',
+      ['Number','-','Number']=>'Number',
+      ['Number','*','Number']=>'Number',
+      ['Number','/','Number']=>'Number',
+      ['Number','%','Number']=>'Number',
+      ['String','+','String']=>'String',
+      ['Number','<','Number']=>'Boolean',
+      ['Number','>','Number']=>'Boolean',
+      ['Number','<=','Number']=>'Boolean',
+      ['Number','>=','Number']=>'Boolean',
+      ['Number','==','Number']=>'Boolean',
+      ['Number','!=','Number']=>'Boolean',
+      ['String','==','String']=>'Boolean',
+      ['String','!=','String']=>'Boolean',
+      ['Boolean','==','Boolean']=>'Boolean',
+      ['Boolean','!=','Boolean']=>'Boolean',
+      ['Boolean','&&','Boolean']=>'Boolean',
+      ['Boolean','||','Boolean']=>'Boolean',
+    }
+
+    UNARY = {
+      ['-', 'Number']=>'Number',
+      ['!', 'Boolean']=>'Boolean',
+    }
+
+    #### 符号表 / 作用域 ####
+
+    Scope = Struct.new(:vars, :funcs, :parent) do
+      def initialize(parent=nil)
+        self.vars = {}
+        self.funcs = {}
+        self.parent = parent
+      end
+      def lookup_var name
+        vars[name] || (parent && parent.lookup_var(name))
+      end
+      def lookup_fn name
+        funcs[name] || (parent && parent.lookup_fn(name))
+      end
+      def define_var name, type, line
+        if vars[name]
+          return [:error, "变量 '#{name}' 在同一作用域内重复声明 (line #{line})"]
+        end
+        vars[name] = type
+        nil
+      end
+      def define_fn name, sig, line
+        funcs[name] = sig
+        nil
+      end
+    end
+
+    #### 主入口 ####
+
+    def analyze ast
+      @errors = []
+      @scope = Scope.new
+      @advisor_suggestions = []
+      walk ast, @scope
+      { ast:ast, errors:@errors, types:@scope, suggestions:@advisor_suggestions }
+    end
+
+    #### AST 遍历 ####
+
+    def walk node, sc
+      return nil unless node
+      case node[:type]
+      when 'Program'
+        node[:body].each{|s| walk(s, sc) }
+      when 'LetDecl'
+        walk_let(node, sc)
+      when 'FnDecl'
+        walk_fn(node, sc)
+      when 'IfStmt'
+        walk_if(node, sc)
+      when 'WhileStmt'
+        ct = walk(node[:cond], sc)
+        err node[:line], "while 条件必须为 Boolean, 实际为 #{ct}" if ct && ct != 'Boolean'
+        walk(node[:body], Scope.new(sc))
+      when 'ReturnStmt'
+        walk(node[:value], sc) if node[:value]
+      when 'Block'
+        inner = Scope.new(sc)
+        node[:body].each{|s| walk(s, inner) }
+      when 'ExprStmt'
+        walk(node[:expr], sc)
+      when 'Assign'
+        walk_assign(node, sc)
+      when 'Binary'
+        walk_binary(node, sc)
+      when 'Unary'
+        walk_unary(node, sc)
+      when 'NumLit'
+        'Number'
+      when 'StrLit'
+        'String'
+      when 'BoolLit'
+        'Boolean'
+      when 'Ident'
+        t = sc.lookup_var(node[:name])
+        err node[:line], "变量 '#{node[:name]}' 未声明" unless t
+        t
+      when 'Call'
+        walk_call(node, sc)
+      end
+    end
+
+    #### 各节点处理 ####
+
+    def walk_let node, sc
+      vt = node[:varType]
+      it = walk(node[:value], sc)
+      if vt && it && vt != it
+        # ※ 尝试 LLM 顾问: 隐式类型转换建议
+        err node[:line], "类型不匹配: 声明为 #{vt}, 推断为 #{it}"
+      end
+      t = vt || it || 'Unknown'
+      r = sc.define_var(node[:name], t, node[:line])
+      err(*r) if r
+      t
+    end
+
+    def walk_fn node, sc
+      params = node[:params].inject({}){|h,p| h[p[:name]]=p[:type]; h }
+      sc.define_fn(node[:name], {
+        params:params, retType:node[:retType]
+      }, node[:line])
+      inner = Scope.new(sc)
+      params.each{|n,t| inner.vars[n] = t }
+      walk(node[:body], inner)
+      node[:retType] || 'Void'
+    end
+
+    def walk_if node, sc
+      ct = walk(node[:cond], sc)
+      err node[:line], "if 条件必须为 Boolean, 实际为 #{ct}" if ct && ct != 'Boolean'
+      walk(node[:then], Scope.new(sc))
+      walk(node[:els], Scope.new(sc)) if node[:els]
+    end
+
+    def walk_assign node, sc
+      lt = walk(node[:target], sc)
+      rt = walk(node[:value], sc)
+      if lt && rt && lt != rt
+        err node[:line], "赋值类型不匹配: #{lt} ≠ #{rt}"
+      end
+      lt
+    end
+
+    def walk_binary node, sc
+      lt = walk(node[:left], sc)
+      rt = walk(node[:right], sc)
+      key = [lt, node[:op], rt]
+      r = RULES[key]
+      unless r
+        # ★ 规则未覆盖 → 尝试 LLM 顾问 (可选, 默认降级)
+        # 这里确定性兜底: 标记为 Unknown
+        r = 'Unknown'
+      end
+      node[:inferredType] = r
+      r
+    end
+
+    def walk_unary node, sc
+      ot = walk(node[:operand], sc)
+      r = UNARY[[node[:op], ot]] || 'Unknown'
+      node[:inferredType] = r
+      r
+    end
+
+    def walk_call node, sc
+      fn = sc.lookup_fn(node[:name])
+      unless fn
+        err node[:line], "函数 '#{node[:name]}' 未声明"
+        return 'Unknown'
+      end
+      # ※ 参数数量检查
+      decl_params = fn[:params].keys
+      if node[:args].length != decl_params.length
+        err node[:line], "函数 '#{node[:name]}' 参数数量不匹配: 期望 #{decl_params.length} 实际 #{node[:args].length}"
+      end
+      # 参数类型检查
+      node[:args].each_with_index do|arg, i|
+        at = walk(arg, sc)
+        pn = decl_params[i]
+        pt = fn[:params][pn]
+        if at && pt && at != pt
+          err node[:line], "参数类型不匹配: '#{pn}' 期望 #{pt} 实际 #{at}"
+        end
+      end
+      fn[:retType] || 'Unknown'
+    end
+
+    def err line, msg
+      @errors << { line:line, msg:msg }
+      $stderr.puts "[semantic] line #{line}: #{msg}"
+    end
+
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: infornoid
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- numeron
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Infornoid 是一个采用混合架构设计的智能编译器：确定性编译器保证安全性与
+  可预测性，LLM 作为顾问提供优化建议，不直接生成可执行代码。零第三方依赖，
+  纯 Ruby 标准库实现。支持子命令风格 CLI（compile/lex/parse/semantic/
+  optimize/codegen/check），可编译为 JavaScript 或 Python 目标代码。
+email:
+- numeron@example.com
+executables:
+- infornoid
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/infornoid
+- lib/advisor.rb
+- lib/codegen.rb
+- lib/infornoid.rb
+- lib/lexer.rb
+- lib/optimizer.rb
+- lib/parser.rb
+- lib/semantic.rb
+homepage: https://github.com/numeron/infornoid
+licenses:
+- AGPL-3.0-only
+metadata:
+  source_code_uri: https://github.com/numeron/infornoid
+  changelog_uri: https://github.com/numeron/infornoid/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: 混合架构智能编译器 — 确定性前端 + LLM 顾问优化 + 确定性代码生成
+test_files: []