Update local bindings on function with type use (#1466)

When a function is specified like this:

    (func (type $t) ...)

the type can have any sequence of params and results, but it is not
known what that signature is until it is resolved. However, locals that
are parsed will be given a binding index under the assumption that the
signature is empty, e.g.

    (func (type $t)
      (local $v0 i32)
      (local $v1 i32)
      ...
    )

So `$v0` will have index 0, and `$v1` will have index 1. If it turns out
later that type `$t` has any parameters, then these indexes need to be
updated.

Author: binji

src/wast-parser.cc

@@ -243,17 +243,18 @@ bool IsEmptySignature(const FuncSignature& sig) {
   return sig.result_types.empty() && sig.param_types.empty();
 }
 
-void ResolveFuncTypeWithEmptySignature(const Module& module,
+bool ResolveFuncTypeWithEmptySignature(const Module& module,
                                        FuncDeclaration* decl) {
   // Resolve func type variables where the signature was not specified
   // explicitly, e.g.: (func (type 1) ...)
   if (decl->has_func_type && IsEmptySignature(decl->sig)) {
     const FuncType* func_type = module.GetFuncType(decl->type_var);
     if (func_type) {
       decl->sig = func_type->sig;
+      return true;
     }
   }
-
+  return false;
 }
 
 void ResolveImplicitlyDefinedFunctionType(const Location& loc,
@@ -419,14 +420,28 @@ Result ResolveFuncTypes(Module* module, Errors* errors) {
       continue;
     }
 
+    bool has_func_type_and_empty_signature = false;
+
     if (decl) {
-      ResolveFuncTypeWithEmptySignature(*module, decl);
+      has_func_type_and_empty_signature =
+          ResolveFuncTypeWithEmptySignature(*module, decl);
       ResolveImplicitlyDefinedFunctionType(field.loc, module, *decl);
       result |=
           CheckFuncTypeVarMatchesExplicit(field.loc, *module, *decl, errors);
     }
 
     if (func) {
+      if (has_func_type_and_empty_signature) {
+        // The call to ResolveFuncTypeWithEmptySignature may have updated the
+        // function signature so there are parameters. Since parameters and
+        // local variables share the same index space, we need to increment the
+        // local indexes bound to a given name by the number of parameters in
+        // the function.
+        for (auto& pair: func->bindings) {
+          pair.second.index += func->GetNumParams();
+        }
+      }
+
       ResolveFuncTypesExprVisitorDelegate delegate(module, errors);
       ExprVisitor visitor(&delegate);
       result |= visitor.VisitFunc(func);

test/desugar/locals.txt

@@ -0,0 +1,14 @@
+;;; TOOL: wat-desugar
+(module
+  (type (func (param i32) (result i32)))
+  (func (type 0) (local $var i32)
+        (local.get 0)
+        (local.tee $var)))
+(;; STDOUT ;;;
+(module
+  (type (;0;) (func (param i32) (result i32)))
+  (func (;0;) (type 0) (param i32) (result i32)
+    (local $var i32)
+    local.get 0
+    local.tee 0))
+;;; STDOUT ;;)