aspect Preparation {

  // 0.5 s

/*
  protected boolean MethodAccess.isExactMethodAccess() { return true; }
  protected boolean StaticMethodAccess.isExactMethodAccess() { return false; }
  protected boolean VirtualMethodAccess.isExactMethodAccess() { return false; }
  rewrite MethodAccess {
    when (isExactMethodAccess() && decl().isStatic())
      to MethodAccess new StaticMethodAccess(getArgList(), getIdUse());
    when (isExactMethodAccess() && !decl().isStatic())
      to MethodAccess new VirtualMethodAccess(getArgList(), getIdUse());
  }
  */

  // ~0 s
  rewrite VariableDeclaration {
    when (!duringVariableDeclaration() && !duringResolveAmbiguousNames() &&hasAbstractVarInit() && getAbstractVarInit() instanceof ArrayInit)
    to VariableDeclaration {
      setAbstractVarInit(
          new VarInit(
            new ArrayInstanceExpr(
              (Access)getTypeAccess().fullCopy(),
              new List(),
              new Opt(
                getAbstractVarInit()
                )
              )
            )
          );
      return this;
    }
  }

  /*
   * separate declaration and initalization
   */

/*
  rewrite VariableDeclaration in Block.getStmt() {
    when (!duringVariableDeclaration() && !duringResolveAmbiguousNames() && hasAbstractVarInit() && getAbstractVarInit() instanceof VarInit) 
    to List {
      Expr init = ((VarInit)getAbstractVarInit()).getExpr();
      String name = name();
      setAbstractVarInitOpt(new Opt());
      VariableDeclaration v = new VariableDeclaration(getModifiers(), getTypeAccess(), getIdDecl(), new Opt());
      Stmt assign = new ExprStmt(new AssignSimpleExpr(new VarAccess(new IdUse(name)), init));
      return new List().add(v).add(assign);
    }
  }
  */

  // 1 s
  protected boolean VarAccess.isExactVarAccess() { return true; }
  protected boolean StaticFieldAccess.isExactVarAccess() { return false; }
  protected boolean FieldAccess.isExactVarAccess() { return false; }
  protected boolean LocalVarAccess.isExactVarAccess() { return false; }
  protected boolean ParamVarAccess.isExactVarAccess() { return false; }
  rewrite VarAccess {
    when(isExactVarAccess())
    to VarAccess {
      Variable decl = decl();
      if(decl.isClassVariable())
        return new StaticFieldAccess(getIdUse());
      else if(decl.isInstanceVariable())
        return new FieldAccess(getIdUse());
      else if(decl.isLocalVariable())
        return new LocalVarAccess(getIdUse());
      else if(decl.isMethodParameter() || decl.isConstructorParameter())
        return new ParamVarAccess(getIdUse());
      else if(decl instanceof ParameterDeclaration) 
        return new ParamVarAccess(getIdUse());
      else
        throw new Error("Could not specialize VarAccess that binds to " + decl.getClass().getName());
    }
    
    /*
    when (isExactVarAccess() && decl().isClassVariable())
    to VarAccess new StaticFieldAccess(getIdUse());
    when (isExactVarAccess() && decl().isInstanceVariable())
    to VarAccess new FieldAccess(getIdUse());
    when (isExactVarAccess() && decl().isLocalVariable())
    to VarAccess new LocalVarAccess(getIdUse());
    when (isExactVarAccess() && decl().isMethodParameter())
    to VarAccess new ParamVarAccess(getIdUse());
    */
    
  } 


/*
  protected boolean AssignSimpleExpr.isExactAssignSimpleExpr() { return true; }
  protected boolean ArrayAssignSimpleExpr.isExactAssignSimpleExpr() { return false; }
  protected boolean StaticFieldAssignSimpleExpr.isExactAssignSimpleExpr() { return false; }
  protected boolean FieldAssignSimpleExpr.isExactAssignSimpleExpr() { return false; }
  protected boolean LocalVarAssignSimpleExpr.isExactAssignSimpleExpr() { return false; }
  rewrite AssignSimpleExpr {
    when (isExactAssignSimpleExpr() && getDest() instanceof LocalVarAccess)
    to AssignSimpleExpr new LocalVarAssignSimpleExpr(getDest(), getSource());
    when (isExactAssignSimpleExpr() && (getDest() instanceof FieldAccess || getDest() instanceof FieldDot 
          && ((FieldDot) getDest()).getRight() instanceof FieldAccess))
    to AssignSimpleExpr new FieldAssignSimpleExpr(getDest(), getSource());
    when (isExactAssignSimpleExpr() && (getDest() instanceof StaticFieldAccess || getDest() instanceof FieldDot 
          && ((FieldDot) getDest()).getRight() instanceof StaticFieldAccess))
    to AssignSimpleExpr new StaticFieldAssignSimpleExpr(getDest(), getSource());
    when (isExactAssignSimpleExpr() && getDest() instanceof ArrayDot)
    to AssignSimpleExpr new ArrayAssignSimpleExpr(getDest(), getSource());
  }
*/

  // add implicit this to method invocations

/*
  syn boolean VirtualMethodAccess.canBeQualified() {
    TypeDecl t = hostType();
    while(t != null && !t.hasMethod(name()))
      t = t.enclosingType();
    return t != null;
  }
  rewrite VirtualMethodAccess {
    when(!isQualified() && canBeQualified())
    to MethodDot {
      TypeDecl t = hostType();
      while(!t.hasMethod(name()))
        t = t.enclosingType();
      return new MethodDot(
          new ThisDot(
            t.createQualifiedAccess(),
            new ThisAccess(
              new List(),
              new IdUse("this")
              )
            ),
          this
          );
    }
  }
  */


/*
  // add implicit this to field access
  rewrite FieldAccess {
    when (!isQualified())
    to InstanceFieldDot {
      TypeDecl t = hostType();
      while(t.findVariable(getIdUse()).isEmpty())
        t = t.enclosingType();
      return new InstanceFieldDot(
          new ThisDot(
            t.createQualifiedAccess(),
            new ThisAccess(
              new List(),
              new IdUse("this")
              )
            ),
          this
          );
    }
  }
  */

  rewrite ArrayInstanceExpr {
    when (!(this instanceof RefArrayInstanceExpr) && (type().elementType().isReferenceType()
          || type().dimension() > 1))
      to ArrayInstanceExpr new RefArrayInstanceExpr(getTypeAccess(), getDimsList(), getArrayInitOpt());
    when (!(this instanceof ValArrayInstanceExpr) && (type().elementType().isPrimitiveType()
          && type().dimension() == 1))
      to ArrayInstanceExpr new ValArrayInstanceExpr(getTypeAccess(), getDimsList(), getArrayInitOpt());
  }

  /*
  rewrite AssignMulExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new MulExpr(getDest(), getSource()));
  }
  rewrite AssignDivExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new DivExpr(getDest(), getSource()));
  }
  rewrite AssignModExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new ModExpr(getDest(), getSource()));
  }
  rewrite AssignPlusExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new AddExpr(getDest(), getSource()));
  }
  rewrite AssignMinusExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new SubExpr(getDest(), getSource()));
  }
  rewrite AssignLShiftExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new LShiftExpr(getDest(), getSource()));
  }
  rewrite AssignRShiftExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new RShiftExpr(getDest(), getSource()));
  }
  rewrite AssignURShiftExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new URShiftExpr(getDest(), getSource()));
  }
  rewrite AssignAndExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new AndBitwiseExpr(getDest(), getSource()));
  }
  rewrite AssignXorExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new XorBitwiseExpr(getDest(), getSource()));
  }
  rewrite AssignOrExpr {
    to AssignSimpleExpr new AssignSimpleExpr((Expr)getDest().fullCopy(), new OrBitwiseExpr(getDest(), getSource()));
  }
  */
}