/*

 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import com.sun.tools.javac.code.BoundKind;

import com.sun.tools.javac.code.Flags;

import com.sun.tools.javac.util.Context;

import com.sun.tools.javac.code.Types;

import com.sun.tools.javac.code.Symtab;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.code.Type.*;

import com.sun.tools.javac.code.Symbol.*;

import com.sun.tools.javac.util.List;

import com.sun.tools.javac.util.ListBuffer;

import com.sun.tools.javac.util.Name;

import com.sun.tools.javac.util.Names;

import com.sun.tools.javac.file.JavacFileManager;

/**

 * Test harness whose goal is to simplify the task of writing type-system

 * regression test. It provides functionalities to build custom types as well

 * as to access the underlying javac's symbol table in order to retrieve

 * predefined types. Among the features supported by the harness are: type

 * substitution, type containment, subtyping, cast-conversion, assigment

 * conversion.

 *

 * This class is meant to be a common super class for all concrete type test

 * classes. A subclass can access the type-factory and the test methods so as

 * to write compact tests. An example is reported below:

 *

 * <pre>

 * Type X = fac.TypeVariable();

 * Type Y = fac.TypeVariable();

 * Type A_X_Y = fac.Class(0, X, Y);

 * Type A_Obj_Obj = fac.Class(0,

 *           predef.objectType,

 *           predef.objectType);

 * checkSameType(A_Obj_Obj, subst(A_X_Y,

 *           Mapping(X, predef.objectType),

 *           Mapping(Y, predef.objectType)));

 * </pre>

 *

 * The above code is used to create two class types, namely {@code A<X,Y>} and

 * {@code A<Object,Object>} where both {@code X} and {@code Y} are type-variables.

 * The code then verifies that {@code [X:=Object,Y:=Object]A<X,Y> == A<Object,Object>}.

 *

 * @author mcimadamore

 */

public class TypeHarness {

    protected Types types;

    protected Symtab predef;

    protected Names names;

    protected Factory fac;

    protected TypeHarness() {

        Context ctx = new Context();

        JavacFileManager.preRegister(ctx);

        types = Types.instance(ctx);

        predef = Symtab.instance(ctx);

        names = Names.instance(ctx);

        fac = new Factory();

    }

    // <editor-fold defaultstate="collapsed" desc="type assertions">

    /** assert that 's' is a subtype of 't' */

    public void assertSubtype(Type s, Type t) {

        assertSubtype(s, t, true);

    }

    /** assert that 's' is/is not a subtype of 't' */

    public void assertSubtype(Type s, Type t, boolean expected) {

        if (types.isSubtype(s, t) != expected) {

            String msg = expected ?

                " is not a subtype of " :

                " is a subtype of ";

            error(s + msg + t);

        }

    }

    /** assert that 's' is the same type as 't' */

    public void assertSameType(Type s, Type t) {

        assertSameType(s, t, true);

    }

    /** assert that 's' is/is not the same type as 't' */

    public void assertSameType(Type s, Type t, boolean expected) {

        if (types.isSameType(s, t) != expected) {

            String msg = expected ?

                " is not the same type as " :

                " is the same type as ";

            error(s + msg + t);

        }

    }

    /** assert that 's' is castable to 't' */

    public void assertCastable(Type s, Type t) {

        assertCastable(s, t, true);

    }

    /** assert that 's' is/is not castable to 't' */

    public void assertCastable(Type s, Type t, boolean expected) {

        if (types.isCastable(s, t) != expected) {

            String msg = expected ?

                " is not castable to " :

                " is castable to ";

            error(s + msg + t);

        }

    }

    /** assert that 's' is convertible (method invocation conversion) to 't' */

    public void assertConvertible(Type s, Type t) {

        assertCastable(s, t, true);

    }

    /** assert that 's' is/is not convertible (method invocation conversion) to 't' */

    public void assertConvertible(Type s, Type t, boolean expected) {

        if (types.isConvertible(s, t) != expected) {

            String msg = expected ?

                " is not convertible to " :

                " is convertible to ";

            error(s + msg + t);

        }

    }

    /** assert that 's' is assignable to 't' */

    public void assertAssignable(Type s, Type t) {

        assertCastable(s, t, true);

    }

    /** assert that 's' is/is not assignable to 't' */

    public void assertAssignable(Type s, Type t, boolean expected) {

        if (types.isAssignable(s, t) != expected) {

            String msg = expected ?

                " is not assignable to " :

                " is assignable to ";

            error(s + msg + t);

        }

    }

    // </editor-fold>

    private void error(String msg) {

        throw new AssertionError("Unexpected result: " + msg);

    }

    // <editor-fold defaultstate="collapsed" desc="type functions">

    /** compute the erasure of a type 't' */

    public Type erasure(Type t) {

        return types.erasure(t);

    }

    /** compute the capture of a type 't' */

    public Type capture(Type t) {

        return types.capture(t);

    }

    /** compute the boxed type associated with 't' */

    public Type box(Type t) {

        if (!t.isPrimitive()) {

            throw new AssertionError("Cannot box non-primitive type: " + t);

        }

        return types.boxedClass(t).type;

    }

    /** compute the unboxed type associated with 't' */

    public Type unbox(Type t) {

        Type u = types.unboxedType(t);

        if (t == null) {

            throw new AssertionError("Cannot unbox reference type: " + t);

        } else {

            return u;

        }

    }

    /** compute a type substitution on 't' given a list of type mappings */

    public Type subst(Type t, Mapping... maps) {

        ListBuffer<Type> from = ListBuffer.lb();

        ListBuffer<Type> to = ListBuffer.lb();

        for (Mapping tm : maps) {

            from.append(tm.from);

            to.append(tm.to);

        }

        return types.subst(t, from.toList(), to.toList());

    }

    /** create a fresh type mapping from a type to another */

    public Mapping Mapping(Type from, Type to) {

        return new Mapping(from, to);

    }

    public static class Mapping {

        Type from;

        Type to;

        private Mapping(Type from, Type to) {

            this.from = from;

            this.to = to;

        }

    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="type factory">

    /**

     * This class is used to create Java types in a simple way. All main

     * kinds of type are supported: primitive, reference, non-denotable. The

     * factory also supports creation of constant types (used by the compiler

     * to represent the type of a literal).

     */

    public class Factory {

        private int synthNameCount = 0;

        private Name syntheticName() {

            return names.fromString("A$" + synthNameCount++);

        }

        public ClassType Class(long flags, Type... typeArgs) {

            ClassSymbol csym = new ClassSymbol(flags, syntheticName(), predef.noSymbol);

            csym.type = new ClassType(Type.noType, List.from(typeArgs), csym);

            ((ClassType)csym.type).supertype_field = predef.objectType;

            return (ClassType)csym.type;

        }

        public ClassType Class(Type... typeArgs) {

            return Class(0, typeArgs);

        }

        public ClassType Interface(Type... typeArgs) {

            return Class(Flags.INTERFACE, typeArgs);

        }

        public ClassType Interface(long flags, Type... typeArgs) {

            return Class(Flags.INTERFACE | flags, typeArgs);

        }

        public Type Constant(byte b) {

            return predef.byteType.constType(b);

        }

        public Type Constant(short s) {

            return predef.shortType.constType(s);

        }

        public Type Constant(int i) {

            return predef.intType.constType(i);

        }

        public Type Constant(long l) {

            return predef.longType.constType(l);

        }

        public Type Constant(float f) {

            return predef.floatType.constType(f);

        }

        public Type Constant(double d) {

            return predef.doubleType.constType(d);

        }

        public Type Constant(char c) {

            return predef.charType.constType(c + 0);

        }

        public ArrayType Array(Type elemType) {

            return new ArrayType(elemType, predef.arrayClass);

        }

        public TypeVar TypeVariable() {

            return TypeVariable(predef.objectType);

        }

        public TypeVar TypeVariable(Type bound) {

            TypeSymbol tvsym = new TypeSymbol(0, syntheticName(), null, predef.noSymbol);

            tvsym.type = new TypeVar(tvsym, bound, null);

            return (TypeVar)tvsym.type;

        }

        public WildcardType Wildcard(BoundKind bk, Type bound) {

            return new WildcardType(bound, bk, predef.boundClass);

        }

        public CapturedType CapturedVariable(Type upper, Type lower) {

            return new CapturedType(syntheticName(), predef.noSymbol, upper, lower, null);

        }

        public ClassType Intersection(Type classBound, Type... intfBounds) {

            ClassType ct = Class(Flags.COMPOUND);

            ct.supertype_field = classBound;

            ct.interfaces_field = List.from(intfBounds);

            return ct;

        }

    }

    // </editor-fold>

}