fix: block-scope internal temps and include target in collectStmtNames

Address bugbot findings:

1. Wrap call/revert/sizeCheck in a YulStmt.block so __ecwr_success is
   block-scoped. This prevents duplicate let declarations when multiple
   externalCallWithReturn statements appear in the same function body.
   The resultVar binding remains flat-scoped (outside the block) so
   subsequent statements can reference it.

2. Include the target expression in collectStmtNames for
   externalCallWithReturn, matching all other handler functions.

Adds test: multiple externalCallWithReturn in same function compiles
without collision.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Th0rgal

Compiler/ContractSpec.lean

@@ -604,8 +604,8 @@ private partial def collectStmtNames : Stmt → List String
   | Stmt.internalCall functionName args => functionName :: collectExprListNames args
   | Stmt.internalCallAssign names functionName args =>
       names ++ functionName :: collectExprListNames args
-  | Stmt.externalCallWithReturn resultVar _ _ args _ =>
-      resultVar :: collectExprListNames args
+  | Stmt.externalCallWithReturn resultVar target _ args _ =>
+      resultVar :: collectExprNames target ++ collectExprListNames args
 
 private partial def collectStmtListNames : List Stmt → List String
   | [] => []
@@ -3607,10 +3607,14 @@ def compileStmt (fields : List Field) (events : List EventDef := [])
       let sizeCheck := YulStmt.if_ (YulExpr.call "lt" [YulExpr.call "returndatasize" [], YulExpr.lit 32]) [
         YulStmt.expr (YulExpr.call "revert" [YulExpr.lit 0, YulExpr.lit 0])
       ]
-      -- Step 6: extract return value (call/staticcall already copied returndata to memory[0..32])
+      -- Wrap call + checks in a block so __ecwr_success is block-scoped.
+      -- This avoids duplicate let declarations when multiple externalCallWithReturn
+      -- statements appear in the same function body.
+      let callBlock := YulStmt.block ([storeSelector] ++ storeArgs ++ [letSuccess, revertBlock, sizeCheck])
+      -- Step 6: extract return value outside the block (call already copied returndata to memory[0..32])
+      -- resultVar is flat-scoped so subsequent statements can reference it.
       let bindResult := YulStmt.let_ resultVar (YulExpr.call "mload" [YulExpr.lit 0])
-      -- Emit statements flat (not in a block) so resultVar is visible to subsequent statements
-      pure ([storeSelector] ++ storeArgs ++ [letSuccess, revertBlock, sizeCheck, bindResult])
+      pure [callBlock, bindResult]
   | Stmt.returnValues values => do
       if isInternal then
         if values.length != internalRetNames.length then

Compiler/ContractSpecFeatureTest.lean

@@ -4619,4 +4619,31 @@ private def externalCallWithReturnSpec : ContractSpec := {
   | .ok _ =>
       IO.println "✓ externalCallWithReturn staticcall accepted for view function"
 
+-- Test: multiple externalCallWithReturn in same function (no duplicate let collision)
+#eval! do
+  let multiCallSpec : ContractSpec := {
+    name := "MultiExternalCall"
+    fields := []
+    constructor := none
+    functions := [
+      { name := "getPrices"
+        params := [{ name := "oracle1", ty := ParamType.address }, { name := "oracle2", ty := ParamType.address }]
+        returnType := none
+        body := [
+          Stmt.externalCallWithReturn "price1" (Expr.param "oracle1") 0xa035b1fe [] (isStatic := true),
+          Stmt.externalCallWithReturn "price2" (Expr.param "oracle2") 0xa035b1fe [] (isStatic := true),
+          Stmt.stop
+        ]
+      }
+    ]
+  }
+  match compile multiCallSpec [1] with
+  | .error err =>
+      throw (IO.userError s!"✗ multiple externalCallWithReturn should compile: {err}")
+  | .ok ir =>
+      let rendered := Yul.render (emitYul ir)
+      assertContains "multi externalCallWithReturn both bindings" rendered
+        ["let price1 := mload(0)", "let price2 := mload(0)"]
+      IO.println "✓ multiple externalCallWithReturn in same function compiles without collision"
+
 end Compiler.ContractSpecFeatureTest