sclass LASClassDef extends HasTokenRangeWithSrc {

  settable S userGivenName;

  settable S classDefPrefix = "userCode.";

  settable bool fullCompilation;

  settable bool verbose = true;

  replace Tb with GazelleV_LeftArrowScript.

  delegate FunctionDef, Evaluable, Script to Tb.

  transient Class resolvedClass;

  settable Type superClass = O.class;

  new L<FieldDef> fields;

  new Map<S, FieldDef> fieldsByName;

  new L<FunctionDef> methods;

  new MultiMap<S, FunctionDef> methodsByName;

  new L<FunctionDef> methodBodies;

  new L<Type> interfaces;

  FunctionDef initializerMethod;

  new L<Evaluable> initializers;

  new BitSet isFieldInitializer;

  //new L<Evaluable> staticInitializers;

  new LPair<S, Evaluable> staticFieldInitializers;

  sclass FieldDef {

    settable S name;

    settable Type type;

    settable Evaluable initializer;

    Set<S> modifiers;

    transient FieldGen bcel;

    bool hasModifier(S modifier) { ret contains(modifiers, modifier); }

    void addModifier(S modifier) { modifiers = createOrAddToSet(modifiers, modifier); }

    bool isStatic() { ret hasModifier("static"); }

  }

  S structForHash() {

    ret Tb.scriptStruct(litorderedmap(

      +userGivenName, +fields, +methods, +fullCompilation

    ));

  }

  simplyCached S classHash() {

    S struct = structForHash();

    if (verbose) print(structForHash := struct);

    ret md5(struct);

  }

  S finalClassName() {

    ret classDefPrefix() + finalClassNameWithoutPrefix();

  }

  S finalClassNameWithoutPrefix() {

    ret or2(userGivenName, "C") + "_" + classHash();

  }

  Class typeToClassNonNull(Type t) {

    Class c = typeToClass(t);

    if (t != null && c == null)

      fail("Can't resolve type to class: " + toStringWithClassName(t));

    ret c;

  }

  simplyCached byte[] toBytes() {

    ClassMaker classMaker = new(finalClassName(), className(typeToClassNonNull(superClass)),

      mapToStringArray(interfaces, i -> className(typeToClassNonNull(i))));

    var cp = classMaker.getConstantPool();

    for (field : fields) {

      var type = field.type;

      assertNotNull(+type);

      var bcelType = typeToBCELType(type);

      assertNotNull(+bcelType);

      var fg = new FieldGen(

        Const.ACC_PUBLIC, bcelType,

        field.name, cp);

      fg.isTransient(field.hasModifier("transient"));

      fg.isStatic(field.isStatic());

      if (type cast ParameterizedType)

        fg.addAttribute(new org.apache.bcel.classfile.Signature(

          cp.addUtf8("Signature"), 2,

          cp.addUtf8(typeToVMSignature(type)),

          cp.getConstantPool()));

      classMaker.addField(fg);

      field.bcel = fg;

    }

    if (nempty(initializers)) {

      addMethod(initializerMethod = new FunctionDef("$initFields", new S[0], new Script(initializers)).returnType(void.class));

      if (!hasUserDefinedDefaultConstructor())

        addMethod(new FunctionDef("<init>", new S[0], new Script(emptyList())).returnType(void.class));

    }

    for (method : methods)

      if (fullCompilation)

        fullyCompileMethod(classMaker, method);

      else

        semiCompileMethod(classMaker, method);

    if (!hasUserDefinedDefaultConstructor())

      classMaker.addDefaultConstructor();

    if (srcRef() != null)

      classMaker.addField(new FieldGen(

        Const.ACC_PUBLIC | Const.ACC_STATIC, classToBCELType(TokenRangeWithSrc),

        srcRefField(), classMaker.getConstantPool()));

    ret classMaker.toBytes();

  }

  TokenRangeWithSrc srcRef() { ret tokenRangeWithSrc(); }

  void addToInitializerMethod(FieldDef field) {

    if (field.isStatic()) ret;

    isFieldInitializer.set(l(initializers));

    initializers.add(

      new Tb.SetField(new Tb.GetVar("this"), field.name, field.initializer));

  }

  bool hasUserDefinedDefaultConstructor() {

    ret any(methods, m -> m.isConstructor() && empty(m.args));

  }

  // generate interpreted method (slower but always works)

  // like this:

  //

  // new FlexibleVarContext ctx;

  // ctx.put("this", this);

  // ctx.put("arg1", arg1);

  // ctx.put("arg2", arg2);

  // ret methodBody.get(ctx);

  void semiCompileMethod(ClassMaker classMaker, FunctionDef method) {

    // make static field for method body later

    int iMethod = l(methodBodies);

    methodBodies.add(method);

    S bodyFieldName = "_body" + iMethod;

    classMaker.addField(new FieldGen(

      Const.ACC_PUBLIC | Const.ACC_STATIC, classToBCELType(Evaluable.class),

      bodyFieldName, classMaker.getConstantPool()));

    int nArgs = l(method.args);

    MethodMaker mm = new(classMaker.cg(), Const.ACC_PUBLIC, typeToBCEL(method.returnType), method.name,

      mapToArray typeToBCEL(method.argTypes));

    int iThis = 0, iCtx = mm.frameSize;

    // If we are compiling a constructor, call the superclass constructor and $initFields

    if (method.isConstructor()) {

      mm.aload(iThis);

      mm.invokeConstructor(typeToClass(superClass));

      if (initializerMethod != null) {

        mm.aload(iThis);

        mm.il.append(mm.factory.createInvoke(classMaker.className(), initializerMethod.name,

          mm.wrapType(void.class),

          mm.wrapTypes(new Class[0]), Const.INVOKESPECIAL));

      }

    }

    // new FlexibleVarContext ctx;

    mm.newObject(FlexibleVarContext);

    mm.astore(iCtx);

    // ctx.put("this", this);

    mm.aload(iCtx);

    mm.stringConstant("this");

    mm.aload(iThis);

    mm.invokeVirtual(VarContext, void.class, "put", S, O);

    // ctx.put("arg<n>", arg<n>);

    for iArg to nArgs: {

      mm.aload(iCtx);

      mm.stringConstant(method.args[iArg]);

      mm.aloadArgWithAutoboxing(iArg);

      mm.invokeVirtual(VarContext, void.class, "put", S, O);

    }

    // ret methodBody.get(ctx);

    mm.getStaticField(classMaker.className(), bodyFieldName, Evaluable.class);

    mm.aload(iCtx);

    mm.invokeInterface(Evaluable.class, O, "get", VarContext);

    // cast and return

    Type type = method.returnType();

    if (type == void.class)

      mm.return();

    else {

      if (type cast Class && isPrimitiveType(type)) {

        // unbox primitive value

        Class c = type;

        Class boxed = primitiveToBoxedType(c);

        mm.checkCast(typeToBCEL(boxed));

        mm.invokeVirtual(boxed, c, c + "Value");

        mm.returnPrimitive(c);

      } else {

        if (type != O) 

          mm.checkCast(typeToBCEL(type));

        mm.areturn();

      }

    }

    mm.done();

    //print("Made method " + mm.mg.getMethod());

  }

  // fully compile method to byte code (this works only for very simple methods)

  void fullyCompileMethod(ClassMaker classMaker, FunctionDef method) {

    MethodMaker mm = new(classMaker, typeToClass(method.returnType()), method.name,

      repArray(Class.class, O.class, l(method.args)));

    var tbc = LASToByteCode(mm) {

      JVMStackCellType compileGetVar(Tb.GetVar code) {

        // load "this"

        if (eq(code.var, "this")) {

          mm.aload(0);

          ret JVMStackCellType.objValue;

        }

        // load method argument

        int iArg = indexOf(method.args, code.var);

        if (iArg >= 0) {

          mm.aload(iArg+1);

          ret JVMStackCellType.objValue;

        }

        ret super.compileGetVar(code);

      }

    };

    tbc.postConversion = stackTop -> mm.convertToObject(stackTop);

    tbc.compileScript(method.body);

    mm.areturn();

    mm.done();

  }

  void init(Class c) {

    if (resolvedClass != null) ret;

    resolvedClass = c;

    for iMethod over methodBodies: {

      S bodyFieldName = "_body" + iMethod;

      set(c, bodyFieldName, methodBodies.get(iMethod).body);

    }

    for (field : fields)

      if (field.isStatic() && field.initializer != null)

        set(c, field.name, field.initializer.get());

    setOpt(c, srcRefField(), srcRef());

  }

  ResolvableLASClass resolvable(ILASClassLoader lasClassLoader) {

    ret new ResolvableLASClass(lasClassLoader, this);

  }

  O typeToBCEL(LASValueDescriptor descriptor) {

    ret or(descriptor?.javaClass(), O);

  }

  O typeToBCEL(Type type) {

    try object resolvableClassToName(type);

    ret typeToClass(type);

  }

  void addField(FieldDef field) {

    fields.add(field);

    fieldsByName.put(field.name, field);

    if (field.initializer != null)

      addToInitializerMethod(field);

  }

  void addMethod(FunctionDef method) {

    methods.add(method);

    methodsByName.put(method.name, method);

  }

  S srcRefField() { ret "__srcRef"; }

}