Step 501: add cross-language port scenario and tests

2026-02-16 22:37:47 -07:00
parent 6e453ed0d0
commit e6ac78e311
4 changed files with 335 additions and 0 deletions
--- a/editor/src/CrossLanguagePortScenarioRunner.h
+++ b/editor/src/CrossLanguagePortScenarioRunner.h
@@ -0,0 +1,127 @@
+#pragma once
+
+// Step 501: Scenario - Cross-Language Port
+// End-to-end scenario for porting a Python ML pipeline to Rust.
+
+#include "BehavioralEquivalence.h"
+#include "ConcurrencyTranslator.h"
+#include "IntentTranslator.h"
+#include "MemoryModelTranslator.h"
+#include "TranspilationConfidence.h"
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+#include <vector>
+
+struct PortedFunctionResult {
+    std::string name;
+    std::string source;
+    std::string intent;
+    bool hotLoop = false;
+    std::vector<std::string> annotations;
+    TranslationChoice translation;
+    ConfidenceScore confidence;
+    BehavioralCheckResult equivalence;
+};
+
+struct CrossLanguagePortScenarioResult {
+    std::string sourceLanguage;
+    std::string targetLanguage;
+    std::string pipelineSource;
+    std::vector<PortedFunctionResult> functions;
+    IntentTranslationResult intentTranslations;
+    MemoryAnalysisResult memoryAnalysis;
+    ConcurrencyAnalysisResult concurrencyAnalysis;
+    std::vector<std::string> reviewRequiredFunctions;
+    std::vector<std::string> notes;
+
+    float averageConfidence() const {
+        if (functions.empty()) return 0.0f;
+        float sum = 0.0f;
+        for (const auto& f : functions) sum += f.confidence.score;
+        return sum / static_cast<float>(functions.size());
+    }
+};
+
+class CrossLanguagePortScenarioRunner {
+public:
+    static CrossLanguagePortScenarioResult run() {
+        CrossLanguagePortScenarioResult out;
+        out.sourceLanguage = "python";
+        out.targetLanguage = "rust";
+
+        const auto funcs = sampleFunctions();
+        out.pipelineSource = composePipelineSource(funcs);
+        out.intentTranslations = IntentTranslator::translate(funcs, out.sourceLanguage, out.targetLanguage);
+        out.memoryAnalysis = MemoryModelTranslator::analyze(
+            out.pipelineSource, out.sourceLanguage, out.targetLanguage);
+        out.concurrencyAnalysis = ConcurrencyTranslator::analyze(
+            out.pipelineSource, out.sourceLanguage, out.targetLanguage);
+
+        for (size_t i = 0; i < funcs.size(); ++i) {
+            PortedFunctionResult pf;
+            pf.name = funcs[i].name;
+            pf.source = funcs[i].source;
+            pf.intent = funcs[i].intent;
+            pf.hotLoop = isHotLoop(funcs[i].source);
+            if (pf.hotLoop) pf.annotations.push_back("@HotLoop(true)");
+            if (!funcs[i].intent.empty()) pf.annotations.push_back("@Intent(" + funcs[i].intent + ")");
+
+            pf.translation = out.intentTranslations.getTranslation(funcs[i].name);
+            pf.confidence = TranspilationScorer::score(
+                funcs[i].name, funcs[i].source, pf.translation.targetCode,
+                out.sourceLanguage, out.targetLanguage, !funcs[i].intent.empty());
+            pf.equivalence = BehavioralChecker::check(
+                funcs[i].name, funcs[i].source, pf.translation.targetCode,
+                out.sourceLanguage, out.targetLanguage, {});
+
+            if (pf.confidence.reviewRequired) out.reviewRequiredFunctions.push_back(pf.name);
+            out.functions.push_back(std::move(pf));
+        }
+
+        out.notes.push_back("Cross-language Python->Rust scenario executed");
+        out.notes.push_back("Includes hot-loop tagging, transpilation confidence, and review surfacing");
+        return out;
+    }
+
+private:
+    static std::vector<FunctionIntent> sampleFunctions() {
+        return {
+            {"train_epoch", "reduce gradient sum",
+             "def train_epoch(samples):\n"
+             "    total = 0\n"
+             "    for i in range(len(samples)):\n"
+             "        total += samples[i]\n"
+             "    return total\n"},
+            {"normalize_scores", "map transform normalize",
+             "def normalize_scores(scores):\n"
+             "    return [s / 255.0 for s in scores]\n"},
+            {"async_fetch_batch", "",
+             "import asyncio\n"
+             "async def async_fetch_batch(client, urls):\n"
+             "    out = []\n"
+             "    for u in urls:\n"
+             "        out.append(await client.get(u))\n"
+             "    return out\n"}
+        };
+    }
+
+    static std::string composePipelineSource(const std::vector<FunctionIntent>& funcs) {
+        std::string out;
+        for (const auto& f : funcs) {
+            if (!out.empty()) out += "\n";
+            out += f.source;
+        }
+        return out;
+    }
+
+    static bool isHotLoop(const std::string& source) {
+        std::string s = source;
+        std::transform(s.begin(), s.end(), s.begin(),
+                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return s.find("for ") != std::string::npos ||
+               s.find("while ") != std::string::npos ||
+               s.find("range(") != std::string::npos;
+    }
+};