feat(language): add functional pipelines, comptime, async/await, context managers, native regex, formatter, linter & fuzzy diagnostics

Author: devsamikhan

examples/language_advanced_showcase.ae

@@ -0,0 +1,69 @@
+// ==============================================================================
+// AETHER Language Showcase: Functional Pipelines, Comptime, Async/Await & Task,
+// Context Managers & LIFO Defer, Native Regex, Diagnostics, Formatter & Linter
+// ==============================================================================
+
+print("=== 1. Functional Collection Pipeline Methods ===")
+let raw_scores = [45, 92, 78, 92, 60, 88, 100, 45]
+let top_bonus_total = raw_scores.unique().sort().filter(|s| s >= 80).map(|s| s + 5).reduce(0, |acc, s| acc + s)
+print("Top bonus total:", top_bonus_total)
+
+print("\n=== 2. Compile-Time Execution (comptime) & Macros ===")
+macro cube(n) {
+    n * n * n
+}
+let FIB_TABLE = comptime {
+    let mut seq = [0, 1]
+    for i in 2..=8 {
+        seq.push(seq[i - 1] + seq[i - 2])
+    }
+    seq
+}
+print("Precomputed FIB_TABLE at compile time:", FIB_TABLE)
+print("macro cube(4):", cube(4))
+
+print("\n=== 3. Async / Await & Structured Task Concurrency ===")
+async fn compute_metric(n) {
+    return n * n + 10
+}
+let t1 = Task.spawn(compute_metric, 6)
+let t2 = Task.spawn(compute_metric, 9)
+let results = Task.all([t1, t2])
+print("Task.all results:", results)
+
+print("\n=== 4. Deterministic Resource Management (with ... as ... & LIFO defer) ===")
+let events = []
+class Session {
+    fn __init__(self, id) {
+        self.id = id
+    }
+    fn __enter__(self) {
+        events.push("open:" + self.id)
+        return self
+    }
+    fn __exit__(self) {
+        events.push("close:" + self.id)
+    }
+}
+
+fn process_request() {
+    defer events.push("cleanup:outer")
+    defer events.push("cleanup:inner")
+    with Session("sess-01") as s {
+        events.push("query:" + s.id)
+    }
+    return "done"
+}
+let _ = process_request()
+print("Lifecycle trace:", events.join(" -> "))
+
+print("\n=== 5. Native Zero-Dependency Regex Engine ===")
+let log_line = "2026-10-23 [ERROR] User #4091 failed login from 10.0.0.12"
+print("Regex is_match:", Regex.is_match("^2026-[0-9]{2}-[0-9]{2}", log_line))
+print("Regex find:", Regex.find("#[0-9]+", log_line))
+print("Regex replace_all:", Regex.replace_all("[0-9]+", log_line, "X"))
+
+print("\n=== 6. Built-in Code Formatter, Linter & Fuzzy Diagnostics ===")
+let sample_code = "fn demo(a){\nlet unused_var = 42\nreturn a+1\n}\n"
+print("Linter warnings:", Linter.lint(sample_code))
+print("Fuzzy suggestion for 'prnt':", Diagnostics.suggest("prnt", ["print", "println", "len"]))

src/lsp.rs

@@ -36,10 +36,30 @@ impl AetherLanguageServer {
     pub fn analyze(&self, source: &str) -> Vec<LspDiagnostic> {
         let mut diagnostics = Vec::new();
 
-        // 1. Syntax Parsing Pass
+        // 1. Syntax Parsing Pass + Semantic Type & Security Checks
         match crate::syntax::parse(source) {
-            Ok(_) => {
-                // Syntax valid - can perform semantic and contract checks
+            Ok(program) => {
+                // Static Type & Trait Completeness Check
+                let mut checker = crate::types::checker::TypeChecker::new();
+                if let Err(type_errs) = checker.check_program(&program) {
+                    for msg in type_errs {
+                        diagnostics.push(LspDiagnostic {
+                            line: 0,
+                            col: 0,
+                            message: format!("Type error: {}", msg),
+                            severity: 2, // Warning
+                        });
+                    }
+                }
+                // Static Security Taint & Vulnerability Check
+                for finding in crate::vm::security::scan_program_security(&program) {
+                    diagnostics.push(LspDiagnostic {
+                        line: finding.line.saturating_sub(1),
+                        col: 0,
+                        message: format!("[{}] {}: {}", finding.severity, finding.category, finding.message),
+                        severity: 2,
+                    });
+                }
             }
             Err((err_msg, span)) => {
                 diagnostics.push(LspDiagnostic {

src/syntax/ast.rs

@@ -130,6 +130,12 @@ pub enum Statement {
         stmt: Box<Statement>,
         span: Span,
     },
+    With {
+        resource: Expr,
+        alias: Option<String>,
+        body: Block,
+        span: Span,
+    },
     Expr(Expr),
 }
 
@@ -186,6 +192,7 @@ impl Statement {
             Statement::ImplDef { span, .. } => *span,
             Statement::TypeAlias { span, .. } => *span,
             Statement::Decorated { span, .. } => *span,
+            Statement::With { span, .. } => *span,
             Statement::Expr(expr) => expr.span(),
         }
     }
@@ -276,6 +283,8 @@ pub enum Expr {
         step: Option<Box<Expr>>,
         span: Span,
     },
+    Await(Box<Expr>, Span),
+    Comptime(Block, Span),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -336,6 +345,8 @@ impl Expr {
             Expr::OptionalIndex(_, _, s) => *s,
             Expr::Try(_, s) => *s,
             Expr::Slice { span, .. } => *span,
+            Expr::Await(_, s) => *s,
+            Expr::Comptime(_, s) => *s,
         }
     }
 }