Merge pull request #2 from Hyper66666/feat/m3-ffi-mvp

feat: FFI MVP and incremental classification hardening

Author: Hyper66666

README.md

@@ -9,6 +9,26 @@ Sengoo is a self-developed compiled language focused on practical engineering ou
 
 Sengoo is still in active development, but the CLI workflow is already usable for real local projects.
 
+## AI Handoff Pack (for other LLMs)
+
+To let another model take over quickly, use:
+
+- `docs/AI_FEWSHOT_PLAYBOOK.md` (few-shot examples with code + why)
+- `sgc --error-format json ...` for machine-readable diagnostics
+- function contracts (`requires` / `ensures`) to encode intent before implementation
+- `--contract-checks auto|on|off` to decide whether runtime contract guards are inserted
+
+Contract example:
+
+```sg
+def divide(a: i64, b: i64) -> i64
+requires b != 0
+ensures result * b == a
+{
+    a / b
+}
+```
+
 ## Practical Demos (Developer-Oriented)
 
 If you want business-style proof points instead of only synthetic microbenchmarks, run:
@@ -229,9 +249,15 @@ Useful commands:
 # type check
 sgc check <file.sg>
 
+# type check (JSON diagnostics for automation/agents)
+sgc --error-format json check <file.sg>
+
 # compile and run
 sgc run <file.sg> -O 1
 
+# compile and run with runtime contract guards (auto: on for O0/O1, off for O2/O3)
+sgc run <file.sg> -O 1 --contract-checks auto
+
 # build native binary
 sgc build <file.sg> -O 2
 
@@ -317,6 +343,26 @@ Sengoo 是一门自研编译型语言，聚焦实际工程落地：
 
 项目仍在快速迭代，但本地 CLI 开发流程已经可用。
 
+## AI 交接包（给其他大模型）
+
+为减少上下文丢失，建议直接使用：
+
+- `docs/AI_FEWSHOT_PLAYBOOK.md`（Few-shot 示例：代码 + 为什么这么写）
+- `sgc --error-format json ...`（机器可读编译诊断）
+- 契约语法 `requires` / `ensures`（先定义意图，再补实现）
+- `--contract-checks auto|on|off`（控制运行时是否插入契约检查）
+
+契约示例：
+
+```sg
+def divide(a: i64, b: i64) -> i64
+requires b != 0
+ensures result * b == a
+{
+    a / b
+}
+```
+
 ## 实用 Demo（面向开发者）
 
 如果你希望看到业务风格的可落地证明，而不是仅有合成微基准，可直接运行：
@@ -526,9 +572,15 @@ target/release/sgc build examples/05_loop.sg -O 2
 # 类型检查
 sgc check <file.sg>
 
+# 类型检查（JSON 诊断，便于自动化/智能体）
+sgc --error-format json check <file.sg>
+
 # 编译并运行
 sgc run <file.sg> -O 1
 
+# 编译并运行（运行时契约检查，auto: O0/O1 开启，O2/O3 关闭）
+sgc run <file.sg> -O 1 --contract-checks auto
+
 # 编译为原生二进制
 sgc build <file.sg> -O 2
 

compiler/src/ast/decl.rs

@@ -76,6 +76,11 @@ impl Decl {
         Self::new(DeclKind::Import(import), span)
     }
 
+    pub fn extern_block(extern_block: ExternBlock) -> Self {
+        let span = extern_block.span;
+        Self::new(DeclKind::ExternBlock(extern_block), span)
+    }
+
     /// 创建模块声明
     pub fn module(module: Module) -> Self {
         let span = module.span;
@@ -95,6 +100,7 @@ impl Decl {
             DeclKind::Const(c) => Some(&c.name),
             DeclKind::Static(s) => Some(&s.name),
             DeclKind::Import(_) => None,
+            DeclKind::ExternBlock(_) => None,
             DeclKind::Module(m) => Some(&m.name),
         }
     }
@@ -112,6 +118,7 @@ impl Decl {
             DeclKind::Const(c) => c.vis.is_public(),
             DeclKind::Static(s) => s.vis.is_public(),
             DeclKind::Import(_) => true,
+            DeclKind::ExternBlock(_) => true,
             DeclKind::Module(m) => m.vis.is_public(),
         }
     }
@@ -156,6 +163,9 @@ pub enum DeclKind {
     /// 导入 `import ...`
     Import(Import),
 
+    /// extern block `extern "C" { ... }`
+    ExternBlock(ExternBlock),
+
     /// 模块 `mod name { ... }`
     Module(Module),
 }
@@ -169,8 +179,14 @@ pub struct Function {
     pub params: Vec<Param>,
     pub self_param: Option<SelfParam>,
     pub return_type: Option<Type>,
+    pub precondition: Option<Box<super::Expr>>,
+    pub postcondition: Option<Box<super::Expr>>,
     pub body: Block,
     pub is_async: bool,
+    pub abi: Option<String>,
+    pub is_unsafe: bool,
+    pub no_mangle: bool,
+    pub export_name: Option<String>,
     pub span: Span,
 }
 
@@ -183,8 +199,14 @@ impl Function {
             params: Vec::new(),
             self_param: None,
             return_type: None,
+            precondition: None,
+            postcondition: None,
             body,
             is_async: false,
+            abi: None,
+            is_unsafe: false,
+            no_mangle: false,
+            export_name: None,
             span,
         }
     }
@@ -226,6 +248,72 @@ impl Node for Function {
     }
 }
 
+/// extern 声明块
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExternBlock {
+    pub abi: String,
+    pub link_name: Option<String>,
+    pub items: Vec<ExternItem>,
+    pub span: Span,
+}
+
+impl ExternBlock {
+    pub fn new(abi: impl Into<String>, span: Span) -> Self {
+        Self {
+            abi: abi.into(),
+            link_name: None,
+            items: Vec::new(),
+            span,
+        }
+    }
+}
+
+impl Node for ExternBlock {
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
+/// extern 块条目
+#[derive(Debug, Clone, PartialEq)]
+pub enum ExternItem {
+    Function(ExternFunction),
+    Static(ExternStatic),
+}
+
+/// extern 函数声明
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExternFunction {
+    pub vis: Visibility,
+    pub name: Ident,
+    pub params: Vec<Param>,
+    pub return_type: Option<Type>,
+    pub is_unsafe: bool,
+    pub span: Span,
+}
+
+impl Node for ExternFunction {
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
+/// extern 静态变量声明
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExternStatic {
+    pub vis: Visibility,
+    pub is_mut: bool,
+    pub name: Ident,
+    pub ty: Type,
+    pub span: Span,
+}
+
+impl Node for ExternStatic {
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
 /// 结构体声明
 #[derive(Debug, Clone, PartialEq)]
 pub struct Struct {

compiler/src/ast/mod.rs

@@ -10,9 +10,9 @@ mod stmt;
 mod ty;
 
 pub use decl::{
-    Class, ClassMember, Const, Decl, DeclKind, Enum, EnumVariant, Function, Impl, Import,
-    ImportKind, Module, Static, Struct, StructField, Trait, TraitItem, TypeAlias, TypeParam,
-    VariantField,
+    Class, ClassMember, Const, Decl, DeclKind, Enum, EnumVariant, ExternBlock, ExternFunction,
+    ExternItem, ExternStatic, Function, Impl, Import, ImportKind, Module, Static, Struct,
+    StructField, Trait, TraitItem, TypeAlias, TypeParam, VariantField,
 };
 pub use expr::{Expr, ExprKind};
 pub use op::{AssignOp, BinOp, UnOp};

compiler/src/ast/ty.rs

@@ -110,7 +110,7 @@ pub enum TypeKind {
     /// 缁犫偓閸楁洝鐭惧鍕閸?`Name` 閹?`module::Name`
     Path(Path),
 
-    /// 濞夋稑鐎风捄顖氱窞缁鐎?Name<T1, T2> 
+    /// 濞夋稑鐎风捄顖氱窞缁鐎?Name<T1, T2>
     PathWithArgs { path: Path, args: Vec<Type> },
 
     /// 閸忓啰绮嶇猾璇茬€?`(Type1, Type2)`

compiler/src/bin/emit_ir.rs

@@ -0,0 +1,43 @@
+use sengoo_compiler::compile_to_ir;
+use std::env;
+use std::fs;
+use std::process::ExitCode;
+
+fn main() -> ExitCode {
+    let mut args = env::args().skip(1);
+    let Some(input_path) = args.next() else {
+        eprintln!("usage: cargo run -p sengoo-compiler --bin emit_ir -- <input.sg> <output.ll>");
+        return ExitCode::from(2);
+    };
+    let Some(output_path) = args.next() else {
+        eprintln!("usage: cargo run -p sengoo-compiler --bin emit_ir -- <input.sg> <output.ll>");
+        return ExitCode::from(2);
+    };
+    if args.next().is_some() {
+        eprintln!("error: too many arguments");
+        return ExitCode::from(2);
+    }
+
+    let source = match fs::read_to_string(&input_path) {
+        Ok(source) => source,
+        Err(err) => {
+            eprintln!("failed to read `{}`: {}", input_path, err);
+            return ExitCode::from(1);
+        }
+    };
+
+    let ir = match compile_to_ir(&source) {
+        Ok(ir) => ir,
+        Err(err) => {
+            eprintln!("failed to compile `{}`: {}", input_path, err);
+            return ExitCode::from(1);
+        }
+    };
+
+    if let Err(err) = fs::write(&output_path, ir) {
+        eprintln!("failed to write `{}`: {}", output_path, err);
+        return ExitCode::from(1);
+    }
+
+    ExitCode::SUCCESS
+}