/*     ____ ____  ____ ____  ______                                     *\
**    / __// __ \/ __// __ \/ ____/    SOcos COmpiles Scala             **
**  __\_ \/ /_/ / /__/ /_/ /\_ \       (c) 2002, LAMP/EPFL              **
** /_____/\____/\___/\____/____/                                        **
**                                                                      **
\*                                                                      */

// $Id$

package scalac.transformer;

import scalac.Global;
import scalac.util.Name;

import scalac.ast.Tree;
import Tree.*;
import scalac.ast.Transformer;

import scalac.symtab.Type;
import scalac.symtab.Symbol;
import scalac.symtab.TermSymbol;
import scalac.symtab.Scope;
import scalac.symtab.Kinds;
import scalac.symtab.Modifiers;

import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;

import scalac.util.Debug;

/**
 * 1. For each class add a single method (DefDef) designated as
 * constructor whose parameters are the class parameters. The
 * constructor contains:
 *   - call to the constructor of the supertype with the appropriate arguments
 *   - initialize the fields corresponding to the class ValDefs
 *   - the bodies of the class level expressions;
 *     they are also removed from the ClassDef body
 *
 * 2. The right hand sides of the ValDefs are left empty
 *
 * 3. Substitute the appropriate constructor symbol into the
 * 'new' expressions
 *
 * @author Nikolay Mihaylov
 * @version 1.2
*/

public class AddConstructors extends Transformer {
    public final static Name CTOR_N = Name.fromString("<init>");

    // True iff we generate code for INT backend.
    protected final boolean forINT;
    // True iff we generate code for JVM backend.
    protected final boolean forJVM;
    // True iff we generate code for MSIL backend.
    protected final boolean forMSIL;

    final HashMap constructors;

    public AddConstructors(Global global, AddConstructorsPhase descr, HashMap constructors) {
	super(global, descr);
        this.constructors = constructors;
        this.forINT = global.target == global.TARGET_INT;
        this.forJVM = global.target == global.TARGET_JVM;
        this.forMSIL = global.target == global.TARGET_MSIL;
    }

    /** return new constructor symbol if it isn't already defined
     */
    Symbol getConstructor(Symbol classConstr) {
	return getConstructor(classConstr,
			      (((Type.MethodType)classConstr.info()).vparams));
    }

    Symbol getConstructor(Symbol classConstr, Symbol[] paramSyms) {
	//assert (classConstr.flags & Modifiers.CONSTRUCTOR) != 0:
// 	assert classConstr.isConstructor() :
// 	    "Constructor functions not implemented yet! " +
// 	    Debug.show(classConstr);
	Symbol constr = (Symbol) constructors.get(classConstr);
	if (constr == null) {
	    Symbol clazz = classConstr.primaryConstructorClass();
            int flags = forJVM
                ? classConstr.flags & (Modifiers.PRIVATE | Modifiers.PROTECTED)
                : classConstr.flags;
	    constr =
                new TermSymbol(classConstr.pos, CTOR_N, clazz, flags);
	    constr.setInfo(Type.MethodType
	    		(paramSyms, //((Type.MethodType)classConstr.info()).vparams,
                         forJVM || forMSIL
                         ? global.definitions.UNIT_TYPE
                         : clazz.type()).erasure());
	    constructors.put(classConstr, constr);
	    constructors.put(constr, constr);
	}
	return constr;
    }

    /** process the tree
     */
    public Tree transform(Tree tree) {
	Symbol treeSym = tree.symbol();
	switch (tree) {
	case ClassDef(_, _, _, ValDef[][] vparams, _, //:
		      Template(Tree[] baseClasses, Tree[] body)):
	    if (treeSym.isInterface())
		return tree;

	    assert treeSym.name.isTypeName();

	    /*
	    System.out.println("Class parameters in the tree:");
	    Param[] pparams = vparams[0];
	    for (int i = 0; i < pparams.length; i++)
		System.out.println("\t" + Debug.show(pparams[i].symbol()));
	    System.out.println("Class parameters in the constructor:");
	    Symbol[] sparams = ((Type.MethodType)treeSym.constructor().info()).vparams;
	    for (int i = 0; i < sparams.length; i++)
		System.out.println("\t" + Debug.show(sparams[i]));
	    */

	    Symbol[] paramSyms = new Symbol[vparams[0].length];
	    for (int i = 0; i < paramSyms.length; i++)
		paramSyms[i] = vparams[0][i].symbol();

	    ArrayList constrBody = new ArrayList();
	    ArrayList classBody = new ArrayList();
	    Symbol constrSym = getConstructor(treeSym.constructor(), paramSyms);
	    Scope classScope = new Scope();
	    classScope.enter(constrSym);

	    // inline the call to the super constructor
            Type superType = treeSym.parents()[0];
            if ( !forINT || !superType.symbol().isJava())
		switch (baseClasses[0]) {
		case Apply(Tree fun, Tree[] args):
		    int pos = baseClasses[0].pos;
		    Tree superConstr = gen.Select
			(gen.Super(pos, superType),
			 getConstructor(fun.symbol()));
		    constrBody.add(gen.Apply(superConstr, transform(args)));
		    break;
		default: assert false;
		}

	    // for every ValDef move the initialization code into the constructor
	    for (int i = 0; i < body.length; i++) {
		Tree t = body[i];
		if (t.definesSymbol()) {
		    Symbol sym = t.symbol();
		    switch (t) {
		    case ValDef(_,_,_,Tree rhs):
			if (rhs != Tree.Empty) {
			    // !!!FIXME: revert to this.whatever when the bug is fixed
			    //Tree ident = gen.Select(gen.This(t.pos, treeSym), sym);
			    Tree ident = gen.Ident(sym);

			    constrBody.add(gen.Assign(t.pos, ident, transform(rhs)));
			    t = gen.ValDef(sym, Tree.Empty);
			}
			break;
		    }
		    classBody.add(transform(t));
		    classScope.enter(sym);
		} else
		    // move every class-level expression into the constructor
		    constrBody.add(transform(t));
	    }

	    // add result expression consistent with the
	    // result type of the constructor
            //if (! forJVM)
            //    constrBody.add(gen.This(tree.pos, treeSym));
            Tree constrTree = constrBody.size() > 1 ?
                gen.Block((Tree[])constrBody.toArray(new Tree[constrBody.size()])):
                (Tree) constrBody.get(0);

	    // add constructor definition to the body of the class
	    classBody.add(gen.DefDef(tree.pos, constrSym, constrTree));

	    // strip off the class constructor from parameters
	    switch (treeSym.constructor().info()) {
	    case MethodType(_, Type result):
		treeSym.constructor().
		    updateInfo(Type.MethodType(Symbol.EMPTY_ARRAY, result));
		break;
	    default : assert false;
	    }

	    Type classType =
// 		Type.CompoundType(treeSym.parents(), classScope);
		Type.compoundType(treeSym.parents(), classScope, treeSym);
	    Symbol classSym = treeSym.updateInfo(classType);
	    //fixConstructor(classSym);

	    Tree[] newBody = (Tree[]) classBody.toArray(Tree.EMPTY_ARRAY);
	    return gen.ClassDef(classSym, newBody);

	// Substitute the constructor into the 'new' expressions
	case New(Template(Tree[] baseClasses, _)):
	    Tree base = baseClasses[0];
	    switch (base) {
	    case Apply(Tree fun, Tree[] args):
		return gen.New(copy.Apply
			       (base,
				gen.Ident(base.pos, getConstructor(fun.symbol())),
				transform(args)));
	    default:
		assert false;
	    }
	    break;

	// is this still needed?
	case Ident(Name name):
	    if (treeSym.isConstructor()) {
		Debug.abort("Not implemented yet: using class constructor as function!");
		//return gen.mkId(tree.pos, getConstructor(treeSym));
	    }
	    //System.out.println("Processing " + Debug.show(treeSym));
	    break;

	// is this still needed?
        case Select(Tree qualifier, Name selector):
            if (treeSym.isConstructor()) {
		Debug.abort("Not implemented yet: using class constructor as function!");
		//return gen.mkSel(tree.pos, transform(qualifier), getConstructor(treeSym));
	    }
            break;

	} // switch(tree)
	return super.transform(tree);
    } // transform()

//     /** Given a symbol of a class it strips off the parameters
//      *  from the MethodType of the constructor of that class
//      *  and all its superclasses
//      */
//     public void fixConstructor(Symbol clazz) {
// 	if (clazz != global.definitions.ANY_CLASS) {
// 	    switch (clazz.constructor().info()) {
// 	    case MethodType(Symbol[] params, Type result):
// 		if (params.length > 0) {
// 		    clazz.constructor().updateInfo
// 			(Type.MethodType(Symbol.EMPTY_ARRAY, result));
// 		}
// 		//fixConstructor(clazz.basetypes()[0].symbol());
// 		break;
// 	    default:
// 		assert false : "Constructor should have a method type!";
// 	    }
// 	}
//     }

} // class AddConstructors