text: // TODO(sven): add flow in here
  
  import { isSignature, isNumberLiteral } from "@webassemblyjs/ast";
  import { assert } from "mamacro";
  
  export function moduleContextFromModuleAST(m) {
    const moduleContext = new ModuleContext();
  
    assert(m.type === "Module");
  
    m.fields.forEach(field => {
      switch (field.type) {
        case "Start": {
          moduleContext.setStart(field.index);
          break;
        }
        case "TypeInstruction": {
          moduleContext.addType(field);
          break;
        }
        case "Func": {
          moduleContext.addFunction(field);
          break;
        }
        case "Global": {
          moduleContext.defineGlobal(field);
          break;
        }
        case "ModuleImport": {
          switch (field.descr.type) {
            case "GlobalType": {
              moduleContext.importGlobal(
                field.descr.valtype,
                field.descr.mutability
              );
              break;
            }
            case "Memory": {
              moduleContext.addMemory(
                field.descr.limits.min,
                field.descr.limits.max
              );
              break;
            }
            case "FuncImportDescr": {
              moduleContext.importFunction(field.descr);
              break;
            }
  
            case "Table": {
              // FIXME(sven): not implemented yet
              break;
            }
  
            default:
              throw new Error(
                "Unsupported ModuleImport of type " +
                  JSON.stringify(field.descr.type)
              );
          }
          break;
        }
        case "Memory": {
          moduleContext.addMemory(field.limits.min, field.limits.max);
          break;
        }
      }
    });
  
    return moduleContext;
  }
  
  /**
   * Module context for type checking
   */
  export class ModuleContext {
    constructor() {
      this.funcs = [];
      this.funcsOffsetByIdentifier = [];
  
      this.types = [];
  
      this.globals = [];
      this.globalsOffsetByIdentifier = [];
  
      this.mems = [];
  
      // Current stack frame
      this.locals = [];
      this.labels = [];
      this.return = [];
  
      this.debugName = "unknown";
  
      this.start = null;
    }
  
    /**
     * Set start segment
     */
    setStart(index) {
      this.start = index.value;
    }
  
    /**
     * Get start function
     */
    getStart() {
      return this.start;
    }
  
    /**
     * Reset the active stack frame
     */
    newContext(debugName, expectedResult) {
      this.locals = [];
      this.labels = [expectedResult];
      this.return = expectedResult;
      this.debugName = debugName;
    }
  
    /**
     * Functions
     */
    addFunction(func /*: Func*/) {
      // eslint-disable-next-line prefer-const
      let { params: args = [], results: result = [] } = func.signature || {};
  
      args = args.map(arg => arg.valtype);
  
      this.funcs.push({ args, result });
  
      if (typeof func.name !== "undefined") {
        this.funcsOffsetByIdentifier[func.name.value] = this.funcs.length - 1;
      }
    }
  
    importFunction(funcimport) {
      if (isSignature(funcimport.signature)) {
        // eslint-disable-next-line prefer-const
        let { params: args, results: result } = funcimport.signature;
        args = args.map(arg => arg.valtype);
  
        this.funcs.push({ args, result });
      } else {
        assert(isNumberLiteral(funcimport.signature));
  
        const typeId = funcimport.signature.value;
        assert(this.hasType(typeId));
  
        const signature = this.getType(typeId);
        this.funcs.push({
          args: signature.params.map(arg => arg.valtype),
          result: signature.results
        });
      }
  
      if (typeof funcimport.id !== "undefined") {
        // imports are first, we can assume their index in the array
        this.funcsOffsetByIdentifier[funcimport.id.value] = this.funcs.length - 1;
      }
    }
  
    hasFunction(index) {
      return typeof this.getFunction(index) !== "undefined";
    }
  
    getFunction(index) {
      if (typeof index !== "number") {
        throw new Error("getFunction only supported for number index");
      }
  
      return this.funcs[index];
    }
  
    getFunctionOffsetByIdentifier(name) {
      assert(typeof name === "string");
  
      return this.funcsOffsetByIdentifier[name];
    }
  
    /**
     * Labels
     */
    addLabel(result) {
      this.labels.unshift(result);
    }
  
    hasLabel(index) {
      return this.labels.length > index && index >= 0;
    }
  
    getLabel(index) {
      return this.labels[index];
    }
  
    popLabel() {
      this.labels.shift();
    }
  
    /**
     * Locals
     */
    hasLocal(index) {
      return typeof this.getLocal(index) !== "undefined";
    }
  
    getLocal(index) {
      return this.locals[index];
    }
  
    addLocal(type) {
      this.locals.push(type);
    }
  
    /**
     * Types
     */
    addType(type) {
      assert(type.functype.type === "Signature");
      this.types.push(type.functype);
    }
  
    hasType(index) {
      return this.types[index] !== undefined;
    }
  
    getType(index) {
      return this.types[index];
    }
  
    /**
     * Globals
     */
    hasGlobal(index) {
      return this.globals.length > index && index >= 0;
    }
  
    getGlobal(index) {
      return this.globals[index].type;
    }
  
    getGlobalOffsetByIdentifier(name) {
      assert(typeof name === "string");
  
      return this.globalsOffsetByIdentifier[name];
    }
  
    defineGlobal(global /*: Global*/) {
      const type = global.globalType.valtype;
      const mutability = global.globalType.mutability;
  
      this.globals.push({ type, mutability });
  
      if (typeof global.name !== "undefined") {
        this.globalsOffsetByIdentifier[global.name.value] =
          this.globals.length - 1;
      }
    }
  
    importGlobal(type, mutability) {
      this.globals.push({ type, mutability });
    }
  
    isMutableGlobal(index) {
      return this.globals[index].mutability === "var";
    }
  
    isImmutableGlobal(index) {
      return this.globals[index].mutability === "const";
    }
  
    /**
     * Memories
     */
    hasMemory(index) {
      return this.mems.length > index && index >= 0;
    }
  
    addMemory(min, max) {
      this.mems.push({ min, max });
    }
  
    getMemory(index) {
      return this.mems[index];
    }
  }
  