infornoid 0.2.0

data/lib/infornoid.rb

@@ -0,0 +1,312 @@
+#coding:utf-8
+# infornoid 智能编译器 — 主驱动
+# 混合架构: 确定性前端 + 规则引擎语义 + LLM 顾问优化 + 确定性代码生成
+# 零第三方依赖, Ruby 标准库实现
+#
+# 子命令风格 CLI (类似 gcc/clang 的分阶段调用):
+#   infornoid compile   <source.inf> [-o out] [--target js|py] [--no-opt] [--llm]
+#   infornoid lex       <source.inf> [--json]          # 输出 Token 列表
+#   infornoid parse     <source.inf> [--json]          # 输出 AST
+#   infornoid semantic  <source.inf> [--json]          # 输出符号表/类型/错误
+#   infornoid optimize  <source.inf> [--json]          # 输出优化后 AST
+#   infornoid codegen   <source.inf> [--target js|py] [--llm]
+#   infornoid check     <source.inf>                   # 仅做语义检查
+#
+# 兼容旧用法 (无子命令时等同 compile):
+#   ruby lib/infornoid.rb <source.inf> [-o out] [--target py] [--ast] [--tokens] [--no-opt] [--llm]
+#
+# 数据流:
+#   源码 → Lexer → Token → Parser → AST → Semantic → Optimizer → Codegen → 目标代码
+
+%w[lexer parser advisor semantic optimizer codegen].each{|f| require_relative f }
+
+module Infor
+  module Compiler
+    module_function
+
+    VERSION = '0.2.0'
+
+    # 子命令 → 处理函数
+    COMMANDS = {
+      'compile'  => :cmd_compile,
+      'lex'      => :cmd_lex,
+      'parse'    => :cmd_parse,
+      'semantic' => :cmd_semantic,
+      'optimize' => :cmd_optimize,
+      'codegen'  => :cmd_codegen,
+      'check'    => :cmd_check,
+    }
+
+    def main argv
+      args = argv.dup
+      cmd  = nil
+
+      # 首个非选项参数若不是已存在文件, 则视为子命令 (兼容: 文件路径 → compile)
+      if args[0] && !args[0].start_with?('-')
+        if COMMANDS.key?(args[0])
+          cmd = args.shift
+        elsif args[0] == 'help'
+          print_help; return 0
+        end
+      end
+
+      # 无子命令 → 默认 compile (兼容旧用法: ruby infornoid.rb <file> ...)
+      cmd ||= 'compile'
+
+      # 兼容旧调试标志: --ast / --tokens → 映射为对应子命令
+      if cmd == 'compile'
+        if args.include?('--tokens')
+          cmd = 'lex';   args.delete('--tokens')
+        elsif args.include?('--ast')
+          cmd = 'parse';  args.delete('--ast')
+        end
+      end
+
+      send(COMMANDS[cmd], args)
+    end
+
+    #### 子命令实现 ####
+
+    # 编译: 完整流水线
+    def cmd_compile argv
+      src_path, out_path, flags = parse_args(argv)
+      unless src_path
+        return err
+      end
+
+      src = read_source(src_path)
+      return 1 unless src
+
+      # 词法
+      ts = Lexer.lex(src)
+      # 语法
+      ast = Parser.parse(ts)
+      # 语义
+      sem = Semantic.analyze(ast)
+      report_errors(sem[:errors]) if sem[:errors].any?
+
+      # 优化
+      unless flags[:no_opt]
+        opt = Optimizer.optimize(ast, flags[:llm])
+        ast = opt[:ast]
+        opt[:log].each{|l| $stderr.puts l }
+      end
+
+      # 代码生成
+      target = map_target(flags[:target])
+      result = Codegen.gen(ast, target, flags[:llm])
+      result[:log].each{|l| $stderr.puts l }
+
+      code = result[:code]
+      if out_path
+        File.open(out_path, 'w:utf-8'){|f| f.puts code }
+        $stderr.puts "[infornoid] 编译完成 → #{out_path}"
+      else
+        $stdout.puts code
+      end
+      0
+    end
+
+    # 词法分析: in [--json]
+    def cmd_lex argv
+      src_path, _, flags = parse_args(argv)
+      return err unless src_path
+      src = read_source(src_path)
+      return 1 unless src
+      ts = Lexer.lex(src)
+      if flags[:json]
+        require 'json'
+        $stdout.puts JSON.pretty_generate(ts)
+      else
+        ts.each{|tk| $stdout.puts "%-6s | %-12s | L%d:C%d"%[tk[:t], tk[:v], tk[:l], tk[:c]] }
+      end
+      0
+    end
+
+    # 语法分析: parse [--json]
+    def cmd_parse argv
+      src_path, _, flags = parse_args(argv)
+      return err unless src_path
+      src = read_source(src_path)
+      return 1 unless src
+      ast = Parser.parse(Lexer.lex(src))
+      require 'json'
+      $stdout.puts flags[:json] ? JSON.pretty_generate(ast) : ast.inspect
+      0
+    end
+
+    # 语义分析: semantic [--json]
+    def cmd_semantic argv
+      src_path, _, flags = parse_args(argv)
+      return err unless src_path
+      src = read_source(src_path)
+      return 1 unless src
+      sem = Semantic.analyze(Parser.parse(Lexer.lex(src)))
+      report_errors(sem[:errors]) if sem[:errors].any?
+      if flags[:json]
+        require 'json'
+        $stdout.puts JSON.pretty_generate(sem)
+      else
+        $stdout.puts "符号表: #{sem[:types].inspect}" if sem[:types]
+        $stdout.puts "错误数: #{sem[:errors].length}"
+      end
+      sem[:errors].any? ? 1 : 0
+    end
+
+    # 优化: optimize [--json]
+    def cmd_optimize argv
+      src_path, _, flags = parse_args(argv)
+      return err unless src_path
+      src = read_source(src_path)
+      return 1 unless src
+      ast = Parser.parse(Lexer.lex(src))
+      opt = Optimizer.optimize(ast, flags[:llm])
+      opt[:log].each{|l| $stderr.puts l }
+      require 'json'
+      $stdout.puts flags[:json] ? JSON.pretty_generate(opt[:ast]) : opt[:ast].inspect
+      0
+    end
+
+    # 代码生成: codegen [--target js|py] [--llm]
+    def cmd_codegen argv
+      src_path, _, flags = parse_args(argv)
+      return err unless src_path
+      src = read_source(src_path)
+      return 1 unless src
+      ast = Parser.parse(Lexer.lex(src))
+      opt = Optimizer.optimize(ast, flags[:llm])
+      result = Codegen.gen(opt[:ast], map_target(flags[:target]), flags[:llm])
+      result[:log].each{|l| $stderr.puts l }
+      $stdout.puts result[:code]
+      0
+    end
+
+    # 语法检查: check (只跑词法+语法+语义, 不输出代码)
+    def cmd_check argv
+      src_path, _, flags = parse_args(argv)
+      return err unless src_path
+      src = read_source(src_path)
+      return 1 unless src
+      sem = Semantic.analyze(Parser.parse(Lexer.lex(src)))
+      if sem[:errors].any?
+        report_errors(sem[:errors])
+        1
+      else
+        $stderr.puts "[infornoid] 语法检查通过 (#{src_path})"
+        0
+      end
+    end
+
+    #### 参数解析 ####
+
+    def parse_args argv
+      src_path = nil
+      out_path = nil
+      flags = { json:false, no_opt:false, llm:false, target:'js' }
+      nxt = nil
+
+      argv.each do|a|
+        case a
+        when '-o'        then nxt = :out
+        when '--target'  then nxt = :target
+        when '--json'    then flags[:json] = true
+        when '--no-opt'  then flags[:no_opt] = true
+        when '--llm'     then flags[:llm] = true
+        when '--help', '-h' then print_help; exit 0
+        when '--version', '-v' then $stdout.puts VERSION; exit 0
+        else
+          case nxt
+          when :out     then out_path = a; nxt = nil
+          when :target  then flags[:target] = a; nxt = nil
+          else src_path = a
+          end
+        end
+      end
+
+      [src_path, out_path, flags]
+    end
+
+    #### 辅助 ####
+
+    def err
+      $stderr.puts "用法: infornoid <source.inf> [选项]"
+      $stderr.puts "运行 --help 查看完整帮助"
+      1
+    end
+
+    def read_source path
+      braw = File.binread(path)
+      begin
+        braw.force_encoding('UTF-8')
+      rescue
+        begin
+          braw.force_encoding('GBK').encode('UTF-8')
+        rescue
+          braw.force_encoding('ASCII-8BIT')
+        end
+      end
+    rescue => e
+      $stderr.puts "[infornoid] 无法读取文件 #{path}: #{e.message}"
+      nil
+    end
+
+    def map_target t
+      case t.to_s.downcase
+      when 'js', 'javascript' then 'JavaScript'
+      when 'py', 'python'     then 'Python'
+      else 'JavaScript'
+      end
+    end
+
+    def report_errors errors
+      $stderr.puts "[infornoid] 语义错误 (#{errors.length} 个):"
+      errors.each{|e| $stderr.puts "  line #{e[:line]}: #{e[:msg]}" }
+    end
+
+    def print_help
+      $stdout.puts <<~HELP
+infornoid v#{VERSION} — LLM 辅助编译器 (混合架构)
+
+用法 (子命令风格):
+  infornoid compile <source.inf> [-o out] [--target js|py] [--no-opt] [--llm]
+  infornoid lex <source.inf> [--json]       输出 Token 列表
+  infornoid parse <source.inf> [--json]     输出 AST
+  infornoid semantic <source.inf> [--json]  输出语义分析结果
+  infornoid optimize <source.inf> [--json]  输出优化后 AST
+  infornoid codegen <source.inf> [--target js|py] [--llm]  仅生成代码
+  infornoid check <source.inf>              语法检查 (不输出代码)
+
+兼容用法 (无子命令时等同 compile):
+  infornoid <source.inf> [-o out] [--target py] [--ast] [--tokens] [--no-opt] [--llm]
+
+选项:
+  -o <file>       指定输出文件路径
+  --target <lang> 目标语言 (js/javascript, py/python), 默认 js
+  --json          以 JSON 输出调试信息 (lex/parse/semantic/optimize)
+  --ast           输出 AST JSON (调试用, 等同 parse)
+  --tokens        输出 Token 列表 (调试用, 等同 lex)
+  --no-opt        跳过优化阶段
+  --llm           启用 LLM 顾问 (需要 Ollama 运行)
+  --help, -h      显示帮助
+  --version, -v   显示版本
+
+架构:
+  源码 → [Lexer] → Token → [Parser] → AST
+       → [Semantic 规则引擎] → Typed AST
+       → [Optimizer LLM顾问+确定性] → Optimized AST
+       → [Codegen 确定性模板] → 目标代码
+
+LLM 顾问:
+  --llm 标志启用后, 在优化和代码生成阶段调用本地 Ollama.
+  LLM 只输出建议性元数据, 不直接生成可执行代码.
+  无 Ollama 时自动降级为纯确定性编译.
+      HELP
+    end
+
+  end
+end
+
+if :main == :main && $0 == __FILE__
+  $rc = Infor::Compiler.main(ARGV)
+  exit($rc || 0)
+end

data/lib/lexer.rb

@@ -0,0 +1,144 @@
+#coding:utf-8
+# infornoid 词法分析器 — 确定性前端
+# 零依赖, 手写扫描器, Token 列表输出
+# CALL: Lexer.lex(source) → [Token]
+# RETN: [{type, value, line, col}]
+
+module Infor
+  module Lexer
+    module_function
+
+    #### token 定义 ####
+
+    KWS = {
+      'let'=>:LET, 'fn'=>:FN, 'if'=>:IF, 'else'=>:ELS,
+      'while'=>:WHL, 'return'=>:RTN, 'true'=>:TRU, 'false'=>:FLS
+    }
+
+    TYS = %w[Number String Boolean Void].inject({}){|h,t| h[t]=:TY; h}
+
+    # 单字符符号表 → token type
+    SMAP = {
+      '('=>:LPR, ')'=>:RPR, '{'=>:LBR, '}'=>:RBR,
+      ';'=>:SCL, ','=>:CMA, ':'=>:COL
+    }
+
+    def lex src
+      ts = []
+      i = 0
+      ln = 1
+      co = 1
+      sl = src.length
+      while i < sl
+        c = src[i]
+        # 空白
+        if c =~ /\s/
+          c == "\n" ? (ln += 1; co = 1) : (co += 1)
+          i += 1
+          next
+        end
+        # 注释 //...
+        if c == '/' && src[i+1] == '/'
+          while i < sl && src[i] != "\n"
+            i += 1; co += 1
+          end
+          next
+        end
+        # 注释 /*...*/
+        if c == '/' && src[i+1] == '*'
+          i += 2; co += 2
+          while i < sl
+            src[i] == "\n" ? (ln += 1; co = 1) : (co += 1)
+            break if src[i] == '*' && src[i+1] == '/'
+            i += 1
+          end
+          i += 2; co += 2
+          next
+        end
+        # 字符串
+        if c == '"'
+          i += 1; co += 1
+          v = ''
+          while i < sl && src[i] != '"'
+            if src[i] == '\\' && i+1 < sl
+              n = src[i+1]
+              v += {'n'=>"\n",'t'=>"\t",'r'=>"\r",'\\'=>'\\','"'=>'"'}[n] || n
+              i += 2; co += 2
+            else
+              v += src[i]; i += 1; co += 1
+            end
+          end
+          err "unterminated string", ln, co and return ts if i >= sl
+          i += 1; co += 1
+          ts << {t: :STR, v:v, l:ln, c:co}
+          next
+        end
+        # 数字
+        if c =~ /[0-9]/
+          s = co
+          v = ''
+          while i < sl && src[i] =~ /[0-9.]/
+            v += src[i]; i += 1; co += 1
+          end
+          ts << {t: :NUM, v:v, l:ln, c:s}
+          next
+        end
+        # 标识符 / 关键字
+        if c =~ /[a-zA-Z_]/
+          s = co
+          v = ''
+          while i < sl && src[i] =~ /[a-zA-Z0-9_]/
+            v += src[i]; i += 1; co += 1
+          end
+          tt = KWS[v] || TYS[v] || :IDT
+          ts << {t:tt, v:v, l:ln, c:s}
+          next
+        end
+        # 多字符运算符
+        if c == '-' && src[i+1] == '>'
+          ts << {t: :ARR, v:'->', l:ln, c:co}
+          i += 2; co += 2
+          next
+        end
+        m2 = { '=='=>:EQ, '!='=>:NE, '<='=>:LE, '>='=>:GE,
+               '&&'=>:AND, '||'=>:OR }[src[i,2]]
+        if m2
+          ts << {t:m2, v:src[i,2], l:ln, c:co}
+          i += 2; co += 2
+          next
+        end
+        # 单字符运算符
+        m1 = { '='=>:ASN, '+'=>:ADD, '-'=>:SUB, '*'=>:MUL, '/'=>:DIV,
+               '%'=>:MOD, '<'=>:LT, '>'=>:GT, '!'=>:NOT }[c]
+        if m1
+          ts << {t:m1, v:c, l:ln, c:co}
+          i += 1; co += 1
+          next
+        end
+        # 分隔符
+        if SMAP[c]
+          ts << {t:SMAP[c], v:c, l:ln, c:co}
+          i += 1; co += 1
+          next
+        end
+        err "unexpected char '#{c}'", ln, co
+        i += 1; co += 1
+      end
+      ts << {t: :EOF, v:'', l:ln, c:co}
+      ts
+    end
+
+    def err msg, ln, co
+      $stderr.puts "[lex error] line %d col %d: %s"%[ln, co, msg]
+    end
+
+  end
+end
+
+if :main == :main && $0 == __FILE__
+  #### 自测 ####
+  while line = ARGF.gets
+    ts = Infor::Lexer.lex(line)
+    ts.each{|tk| puts "%-6s | %-12s | L%d:C%d"%[tk[:t], tk[:v], tk[:l], tk[:c]] }
+  end
+end

data/lib/optimizer.rb

@@ -0,0 +1,238 @@
+#coding:utf-8
+# infornoid 优化器 — LLM 顾问 + 确定性执行
+# 确定性 Pass: 常量折叠, 死代码消除
+# LLM 角色: 分析 IR 输出优化建议元数据, 编译器验证后执行
+# CALL: Optimizer.optimize(ast, use_llm) → {ast, passes, log}
+
+module Infor
+  module Optimizer
+    module_function
+
+    def optimize ast, use_llm = false
+      @log = []
+      @passes = []
+
+      # 1. 确定性常量折叠
+      ast = constant_fold(ast)
+      log_pass 'constant_folding', '常量折叠 (确定性)'
+
+      # 2. 确定性死代码消除
+      before = count_nodes(ast)
+      ast = dead_code_elim(ast)
+      after = count_nodes(ast)
+      if after < before
+        log_pass 'dead_code_elimination', "死代码消除: #{before} → #{after} 节点"
+      end
+
+      # 3. LLM 顾问 (可选)
+      if use_llm
+        advice = Advisor.optimize_advice(ast)
+        if advice[:ok]
+          advice[:suggestions].each do|sg|
+            r = apply_llm_pass(ast, sg)
+            if r && r[:applied]
+              ast = r[:ast]
+              log_pass sg['pass'] || sg[:pass], "LLM 建议: #{sg['reason'] || sg[:reason]}"
+            end
+          end
+        else
+          @log << "[advisor] LLM 降级: #{advice[:reason]}" if advice[:reason]
+        end
+      end
+
+      { ast:ast, passes:@passes, log:@log }
+    end
+
+    #### 常量折叠 — 确定性 ####
+
+    def constant_fold node
+      return nil unless node
+      case node[:type]
+      when 'Program'
+        node[:body] = node[:body].map{|s| constant_fold(s) }.compact
+        node
+      when 'Block'
+        node[:body] = node[:body].map{|s| constant_fold(s) }.compact
+        node
+      when 'FnDecl'
+        node[:body] = constant_fold(node[:body])
+        node
+      when 'LetDecl'
+        node[:value] = constant_fold(node[:value])
+        node
+      when 'IfStmt'
+        node[:cond] = constant_fold(node[:cond])
+        node[:then] = constant_fold(node[:then])
+        node[:els] = constant_fold(node[:els]) if node[:els]
+        # 条件为常量 → 编译时分支消除
+        if node[:cond][:type] == 'BoolLit'
+          return node[:cond][:value] ? node[:then] : (node[:els] || { type:'Block', body:[], line:node[:line] })
+        end
+        node
+      when 'WhileStmt'
+        node[:cond] = constant_fold(node[:cond])
+        node[:body] = constant_fold(node[:body])
+        # 条件为 false → 整个循环消除
+        if node[:cond][:type] == 'BoolLit' && !node[:cond][:value]
+          return nil
+        end
+        node
+      when 'ReturnStmt'
+        node[:value] = constant_fold(node[:value]) if node[:value]
+        node
+      when 'ExprStmt'
+        node[:expr] = constant_fold(node[:expr])
+        node
+      when 'Assign'
+        node[:value] = constant_fold(node[:value])
+        node
+      when 'Binary'
+        node[:left] = constant_fold(node[:left])
+        node[:right] = constant_fold(node[:right])
+        try_fold(node)
+      when 'Unary'
+        node[:operand] = constant_fold(node[:operand])
+        try_fold_unary(node)
+      else
+        node
+      end
+    end
+
+    #尝试折叠二元常量
+    def try_fold node
+      l = node[:left]
+      r = node[:right]
+      return node unless l[:type] == 'NumLit' && r[:type] == 'NumLit'
+      lv = eval_num(l[:value])
+      rv = eval_num(r[:value])
+      result = case node[:op]
+      when '+' then lv + rv
+      when '-' then lv - rv
+      when '*' then lv * rv
+      when '/' then rv == 0 ? nil : lv / rv
+      when '%' then rv == 0 ? nil : lv % rv
+      when '<' then lv < rv
+      when '>' then lv > rv
+      when '<=' then lv <= rv
+      when '>=' then lv >= rv
+      when '==' then lv == rv
+      when '!=' then lv != rv
+      end
+      return node unless result
+      if [true, false].include?(result)
+        { type:'BoolLit', value:result, line:node[:line] }
+      else
+        { type:'NumLit', value:result.to_s, line:node[:line] }
+      end
+    end
+
+    def try_fold_unary node
+      o = node[:operand]
+      return node unless o[:type] == 'NumLit' || o[:type] == 'BoolLit'
+      case node[:op]
+      when '-'
+        v = eval_num(o[:value])
+        { type:'NumLit', value:(-v).to_s, line:node[:line] }
+      when '!'
+        { type:'BoolLit', value:!o[:value], line:node[:line] }
+      else
+        node
+      end
+    end
+
+    #### 死代码消除 — 确定性 ####
+
+    def dead_code_elim node
+      return nil unless node
+      case node[:type]
+      when 'Program', 'Block'
+        node[:body] = node[:body].map{|s| dead_code_elim(s) }.compact
+        # 移除 return 之后的语句
+        ret_idx = node[:body].index{ |s| s[:type] == 'ReturnStmt' }
+        if ret_idx && ret_idx < node[:body].length - 1
+          node[:body] = node[:body][0..ret_idx]
+          @log << "[dce] 移除 return 后的死代码 (line #{node[:line]})"
+        end
+        node
+      when 'FnDecl'
+        node[:body] = dead_code_elim(node[:body])
+        node
+      when 'IfStmt'
+        node[:then] = dead_code_elim(node[:then])
+        node[:els] = dead_code_elim(node[:els]) if node[:els]
+        node
+      when 'WhileStmt'
+        node[:body] = dead_code_elim(node[:body])
+        node
+      else
+        node
+      end
+    end
+
+    #### LLM 顾问建议执行 ####
+
+    def apply_llm_pass ast, suggestion
+      pass = suggestion['pass'] || suggestion[:pass]
+      case pass
+      when 'constant_folding'
+        # 已在确定性阶段完成, 跳过
+        nil
+      when 'dead_code_elimination'
+        # 已在确定性阶段完成, 跳过
+        nil
+      when 'inline_call'
+        # ※ 确定性内联: 仅内联单行函数体
+        r = inline_single_line(ast)
+        r ? { applied:true, ast:r } : nil
+      else
+        # 未实现的 Pass, 跳过
+        nil
+      end
+    end
+
+    #内联仅含单个 return 的函数
+    def inline_single_line ast
+      # 简化实现: 标记但不实际执行内联
+      # 复杂内联需 SSA + 控制流图, 此处保守不执行
+      nil
+    end
+
+    #### 辅助 ####
+
+    def eval_num v
+      v.to_s.include?('.') ? v.to_f : v.to_i
+    end
+
+    def count_nodes node
+      return 0 unless node
+      n = 1
+      case node[:type]
+      when 'Program', 'Block'
+        n += node[:body].inject(0){ |s, c| s + count_nodes(c) }
+      when 'LetDecl', 'ReturnStmt', 'ExprStmt'
+        n += count_nodes(node[:value]) if node[:value]
+        n += count_nodes(node[:expr]) if node[:expr]
+      when 'IfStmt'
+        n += count_nodes(node[:cond]) + count_nodes(node[:then])
+        n += count_nodes(node[:els]) if node[:els]
+      when 'WhileStmt'
+        n += count_nodes(node[:cond]) + count_nodes(node[:body])
+      when 'Binary'
+        n += count_nodes(node[:left]) + count_nodes(node[:right])
+      when 'Unary'
+        n += count_nodes(node[:operand])
+      when 'Assign'
+        n += count_nodes(node[:target]) + count_nodes(node[:value])
+      when 'Call'
+        n += node[:args].inject(0){ |s, a| s + count_nodes(a) }
+      end
+      n
+    end
+
+    def log_pass name, desc
+      @passes << name
+      @log << "[opt] #{name}: #{desc}"
+    end
+
+  end
+end