/*

 * Copyright (c) 1999, 2017, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 */

package com.sun.tools.javac.comp;

import java.util.*;

import javax.tools.JavaFileManager;

import javax.lang.model.element.ElementKind;

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

import com.sun.tools.javac.code.Attribute.Compound;

import com.sun.tools.javac.code.Directive.ExportsDirective;

import com.sun.tools.javac.code.Directive.RequiresDirective;

import com.sun.tools.javac.comp.Annotate.AnnotationTypeMetadata;

import com.sun.tools.javac.jvm.*;

import com.sun.tools.javac.resources.CompilerProperties.Errors;

import com.sun.tools.javac.resources.CompilerProperties.Fragments;

import com.sun.tools.javac.resources.CompilerProperties.Warnings;

import com.sun.tools.javac.tree.*;

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

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

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

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

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.Scope.WriteableScope;

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

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

import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;

import com.sun.tools.javac.comp.Infer.FreeTypeListener;

import com.sun.tools.javac.tree.JCTree.*;

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

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

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

import static com.sun.tools.javac.code.Kinds.*;

import static com.sun.tools.javac.code.Kinds.Kind.*;

import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;

import static com.sun.tools.javac.code.TypeTag.*;

import static com.sun.tools.javac.code.TypeTag.WILDCARD;

import static com.sun.tools.javac.tree.JCTree.Tag.*;

/** Type checking helper class for the attribution phase.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class Check {

    protected static final Context.Key<Check> checkKey = new Context.Key<>();

    private final Names names;

    private final Log log;

    private final Resolve rs;

    private final Symtab syms;

    private final Enter enter;

    private final DeferredAttr deferredAttr;

    private final Infer infer;

    private final Types types;

    private final TypeAnnotations typeAnnotations;

    private final JCDiagnostic.Factory diags;

    private final JavaFileManager fileManager;

    private final Source source;

    private final Profile profile;

    private final boolean warnOnAnyAccessToMembers;

    // The set of lint options currently in effect. It is initialized

    // from the context, and then is set/reset as needed by Attr as it

    // visits all the various parts of the trees during attribution.

    private Lint lint;

    // The method being analyzed in Attr - it is set/reset as needed by

    // Attr as it visits new method declarations.

    private MethodSymbol method;

    public static Check instance(Context context) {

        Check instance = context.get(checkKey);

        if (instance == null)

            instance = new Check(context);

        return instance;

    }

    protected Check(Context context) {

        context.put(checkKey, this);

        names = Names.instance(context);

        dfltTargetMeta = new Name[] { names.PACKAGE, names.TYPE,

            names.FIELD, names.METHOD, names.CONSTRUCTOR,

            names.ANNOTATION_TYPE, names.LOCAL_VARIABLE, names.PARAMETER};

        log = Log.instance(context);

        rs = Resolve.instance(context);

        syms = Symtab.instance(context);

        enter = Enter.instance(context);

        deferredAttr = DeferredAttr.instance(context);

        infer = Infer.instance(context);

        types = Types.instance(context);

        typeAnnotations = TypeAnnotations.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        Options options = Options.instance(context);

        lint = Lint.instance(context);

        fileManager = context.get(JavaFileManager.class);

        source = Source.instance(context);

        allowSimplifiedVarargs = source.allowSimplifiedVarargs();

        allowDefaultMethods = source.allowDefaultMethods();

        allowStrictMethodClashCheck = source.allowStrictMethodClashCheck();

        allowPrivateSafeVarargs = source.allowPrivateSafeVarargs();

        allowDiamondWithAnonymousClassCreation = source.allowDiamondWithAnonymousClassCreation();

        warnOnAnyAccessToMembers = options.isSet("warnOnAccessToMembers");

        Target target = Target.instance(context);

        syntheticNameChar = target.syntheticNameChar();

        profile = Profile.instance(context);

        boolean verboseDeprecated = lint.isEnabled(LintCategory.DEPRECATION);

        boolean verboseRemoval = lint.isEnabled(LintCategory.REMOVAL);

        boolean verboseUnchecked = lint.isEnabled(LintCategory.UNCHECKED);

        boolean enforceMandatoryWarnings = true;

        deprecationHandler = new MandatoryWarningHandler(log, verboseDeprecated,

                enforceMandatoryWarnings, "deprecated", LintCategory.DEPRECATION);

        removalHandler = new MandatoryWarningHandler(log, verboseRemoval,

                enforceMandatoryWarnings, "removal", LintCategory.REMOVAL);

        uncheckedHandler = new MandatoryWarningHandler(log, verboseUnchecked,

                enforceMandatoryWarnings, "unchecked", LintCategory.UNCHECKED);

        sunApiHandler = new MandatoryWarningHandler(log, false,

                enforceMandatoryWarnings, "sunapi", null);

        deferredLintHandler = DeferredLintHandler.instance(context);

    }

    /** Switch: simplified varargs enabled?

     */

    boolean allowSimplifiedVarargs;

    /** Switch: default methods enabled?

     */

    boolean allowDefaultMethods;

    /** Switch: should unrelated return types trigger a method clash?

     */

    boolean allowStrictMethodClashCheck;

    /** Switch: can the @SafeVarargs annotation be applied to private methods?

     */

    boolean allowPrivateSafeVarargs;

    /** Switch: can diamond inference be used in anonymous instance creation ?

     */

    boolean allowDiamondWithAnonymousClassCreation;

    /** Character for synthetic names

     */

    char syntheticNameChar;

    /** A table mapping flat names of all compiled classes for each module in this run

     *  to their symbols; maintained from outside.

     */

    private Map<Pair<ModuleSymbol, Name>,ClassSymbol> compiled = new HashMap<>();

    /** A handler for messages about deprecated usage.

     */

    private MandatoryWarningHandler deprecationHandler;

    /** A handler for messages about deprecated-for-removal usage.

     */

    private MandatoryWarningHandler removalHandler;

    /** A handler for messages about unchecked or unsafe usage.

     */

    private MandatoryWarningHandler uncheckedHandler;

    /** A handler for messages about using proprietary API.

     */

    private MandatoryWarningHandler sunApiHandler;

    /** A handler for deferred lint warnings.

     */

    private DeferredLintHandler deferredLintHandler;

/* *************************************************************************

 * Errors and Warnings

 **************************************************************************/

    Lint setLint(Lint newLint) {

        Lint prev = lint;

        lint = newLint;

        return prev;

    }

    MethodSymbol setMethod(MethodSymbol newMethod) {

        MethodSymbol prev = method;

        method = newMethod;

        return prev;

    }

    /** Warn about deprecated symbol.

     *  @param pos        Position to be used for error reporting.

     *  @param sym        The deprecated symbol.

     */

    void warnDeprecated(DiagnosticPosition pos, Symbol sym) {

        if (sym.isDeprecatedForRemoval()) {

            if (!lint.isSuppressed(LintCategory.REMOVAL)) {

                if (sym.kind == MDL) {

                    removalHandler.report(pos, "has.been.deprecated.for.removal.module", sym);

                } else {

                    removalHandler.report(pos, "has.been.deprecated.for.removal", sym, sym.location());

                }

            }

        } else if (!lint.isSuppressed(LintCategory.DEPRECATION)) {

            if (sym.kind == MDL) {

                deprecationHandler.report(pos, "has.been.deprecated.module", sym);

            } else {

                deprecationHandler.report(pos, "has.been.deprecated", sym, sym.location());

            }

        }

    }

    /** Warn about unchecked operation.

     *  @param pos        Position to be used for error reporting.

     *  @param msg        A string describing the problem.

     */

    public void warnUnchecked(DiagnosticPosition pos, String msg, Object... args) {

        if (!lint.isSuppressed(LintCategory.UNCHECKED))

            uncheckedHandler.report(pos, msg, args);

    }

    /** Warn about unsafe vararg method decl.

     *  @param pos        Position to be used for error reporting.

     */

    void warnUnsafeVararg(DiagnosticPosition pos, String key, Object... args) {

        if (lint.isEnabled(LintCategory.VARARGS) && allowSimplifiedVarargs)

            log.warning(LintCategory.VARARGS, pos, key, args);

    }

    public void warnStatic(DiagnosticPosition pos, String msg, Object... args) {

        if (lint.isEnabled(LintCategory.STATIC))

            log.warning(LintCategory.STATIC, pos, msg, args);

    }

    /** Warn about division by integer constant zero.

     *  @param pos        Position to be used for error reporting.

     */

    void warnDivZero(DiagnosticPosition pos) {

        if (lint.isEnabled(LintCategory.DIVZERO))

            log.warning(LintCategory.DIVZERO, pos, "div.zero");

    }

    /**

     * Report any deferred diagnostics.

     */

    public void reportDeferredDiagnostics() {

        deprecationHandler.reportDeferredDiagnostic();

        removalHandler.reportDeferredDiagnostic();

        uncheckedHandler.reportDeferredDiagnostic();

        sunApiHandler.reportDeferredDiagnostic();

    }

    /** Report a failure to complete a class.

     *  @param pos        Position to be used for error reporting.

     *  @param ex         The failure to report.

     */

    public Type completionError(DiagnosticPosition pos, CompletionFailure ex) {

        log.error(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE, pos, "cant.access", ex.sym, ex.getDetailValue());

        return syms.errType;

    }

    /** Report an error that wrong type tag was found.

     *  @param pos        Position to be used for error reporting.

     *  @param required   An internationalized string describing the type tag

     *                    required.

     *  @param found      The type that was found.

     */

    Type typeTagError(DiagnosticPosition pos, Object required, Object found) {

        // this error used to be raised by the parser,

        // but has been delayed to this point:

        if (found instanceof Type && ((Type)found).hasTag(VOID)) {

            log.error(pos, "illegal.start.of.type");

            return syms.errType;

        }

        log.error(pos, "type.found.req", found, required);

        return types.createErrorType(found instanceof Type ? (Type)found : syms.errType);

    }

    /** Report an error that symbol cannot be referenced before super

     *  has been called.

     *  @param pos        Position to be used for error reporting.

     *  @param sym        The referenced symbol.

     */

    void earlyRefError(DiagnosticPosition pos, Symbol sym) {

        log.error(pos, "cant.ref.before.ctor.called", sym);

    }

    /** Report duplicate declaration error.

     */

    void duplicateError(DiagnosticPosition pos, Symbol sym) {

        if (!sym.type.isErroneous()) {

            Symbol location = sym.location();

            if (location.kind == MTH &&

                    ((MethodSymbol)location).isStaticOrInstanceInit()) {

                log.error(pos, "already.defined.in.clinit", kindName(sym), sym,

                        kindName(sym.location()), kindName(sym.location().enclClass()),

                        sym.location().enclClass());

            } else {

                log.error(pos, "already.defined", kindName(sym), sym,

                        kindName(sym.location()), sym.location());

            }

        }

    }

    /** Report array/varargs duplicate declaration

     */

    void varargsDuplicateError(DiagnosticPosition pos, Symbol sym1, Symbol sym2) {

        if (!sym1.type.isErroneous() && !sym2.type.isErroneous()) {

            log.error(pos, "array.and.varargs", sym1, sym2, sym2.location());

        }

    }

/* ************************************************************************

 * duplicate declaration checking

 *************************************************************************/

    /** Check that variable does not hide variable with same name in

     *  immediately enclosing local scope.

     *  @param pos           Position for error reporting.

     *  @param v             The symbol.

     *  @param s             The scope.

     */

    void checkTransparentVar(DiagnosticPosition pos, VarSymbol v, Scope s) {

        for (Symbol sym : s.getSymbolsByName(v.name)) {

            if (sym.owner != v.owner) break;

            if (sym.kind == VAR &&

                sym.owner.kind.matches(KindSelector.VAL_MTH) &&

                v.name != names.error) {

                duplicateError(pos, sym);

                return;

            }

        }

    }

    /** Check that a class or interface does not hide a class or

     *  interface with same name in immediately enclosing local scope.

     *  @param pos           Position for error reporting.

     *  @param c             The symbol.

     *  @param s             The scope.

     */

    void checkTransparentClass(DiagnosticPosition pos, ClassSymbol c, Scope s) {

        for (Symbol sym : s.getSymbolsByName(c.name)) {

            if (sym.owner != c.owner) break;

            if (sym.kind == TYP && !sym.type.hasTag(TYPEVAR) &&

                sym.owner.kind.matches(KindSelector.VAL_MTH) &&

                c.name != names.error) {

                duplicateError(pos, sym);

                return;

            }

        }

    }

    /** Check that class does not have the same name as one of

     *  its enclosing classes, or as a class defined in its enclosing scope.

     *  return true if class is unique in its enclosing scope.

     *  @param pos           Position for error reporting.

     *  @param name          The class name.

     *  @param s             The enclosing scope.

     */

    boolean checkUniqueClassName(DiagnosticPosition pos, Name name, Scope s) {

        for (Symbol sym : s.getSymbolsByName(name, NON_RECURSIVE)) {

            if (sym.kind == TYP) {

                if (sym.name != names.error)

                    duplicateError(pos, sym);

                return false;

            }

        }

        for (Symbol sym = s.owner; sym != null; sym = sym.owner) {

            if (sym.kind == TYP && sym.name == name && sym.name != names.error) {

                duplicateError(pos, sym);

                return true;

            }

        }

        return true;

    }

/* *************************************************************************

 * Class name generation

 **************************************************************************/

    private Map<Pair<Name, Name>, Integer> localClassNameIndexes = new HashMap<>();

    /** Return name of local class.

     *  This is of the form   {@code <enclClass> $ n <classname> }

     *  where

     *    enclClass is the flat name of the enclosing class,

     *    classname is the simple name of the local class

     */

    Name localClassName(ClassSymbol c) {

        Name enclFlatname = c.owner.enclClass().flatname;

        String enclFlatnameStr = enclFlatname.toString();

        Pair<Name, Name> key = new Pair<>(enclFlatname, c.name);

        Integer index = localClassNameIndexes.get(key);

        for (int i = (index == null) ? 1 : index; ; i++) {

            Name flatname = names.fromString(enclFlatnameStr

                    + syntheticNameChar + i + c.name);

            if (getCompiled(c.packge().modle, flatname) == null) {

                localClassNameIndexes.put(key, i + 1);

                return flatname;

            }

        }

    }

    Name localClassName (final ClassSymbol enclClass, final Name name, final int index) {

        Name flatname = names.

            fromString("" + enclClass.flatname +

                       syntheticNameChar + index +

                       name);

        return flatname;

    }

    void clearLocalClassNameIndexes(ClassSymbol c) {

        if (c.owner != null && c.owner.kind != NIL) {

            localClassNameIndexes.remove(new Pair<>(

                    c.owner.enclClass().flatname, c.name));

        }

    }

    public void newRound() {

        compiled.clear();

        localClassNameIndexes.clear();

    }

    public void putCompiled(ClassSymbol csym) {

        compiled.put(Pair.of(csym.packge().modle, csym.flatname), csym);

    }

    public ClassSymbol getCompiled(ClassSymbol csym) {

        return compiled.get(Pair.of(csym.packge().modle, csym.flatname));

    }

    public ClassSymbol getCompiled(ModuleSymbol msym, Name flatname) {

        return compiled.get(Pair.of(msym, flatname));

    }

    public void removeCompiled(ClassSymbol csym) {

        compiled.remove(Pair.of(csym.packge().modle, csym.flatname));

    }

/* *************************************************************************

 * Type Checking

 **************************************************************************/

    /**

     * A check context is an object that can be used to perform compatibility

     * checks - depending on the check context, meaning of 'compatibility' might

     * vary significantly.

     */

    public interface CheckContext {

        /**

         * Is type 'found' compatible with type 'req' in given context

         */

        boolean compatible(Type found, Type req, Warner warn);

        /**

         * Report a check error

         */

        void report(DiagnosticPosition pos, JCDiagnostic details);

        /**

         * Obtain a warner for this check context

         */

        public Warner checkWarner(DiagnosticPosition pos, Type found, Type req);

        public InferenceContext inferenceContext();

        public DeferredAttr.DeferredAttrContext deferredAttrContext();

    }

    /**

     * This class represent a check context that is nested within another check

     * context - useful to check sub-expressions. The default behavior simply

     * redirects all method calls to the enclosing check context leveraging

     * the forwarding pattern.

     */

    static class NestedCheckContext implements CheckContext {

        CheckContext enclosingContext;

        NestedCheckContext(CheckContext enclosingContext) {

            this.enclosingContext = enclosingContext;

        }

        public boolean compatible(Type found, Type req, Warner warn) {

            return enclosingContext.compatible(found, req, warn);

        }

        public void report(DiagnosticPosition pos, JCDiagnostic details) {

            enclosingContext.report(pos, details);

        }

        public Warner checkWarner(DiagnosticPosition pos, Type found, Type req) {

            return enclosingContext.checkWarner(pos, found, req);

        }

        public InferenceContext inferenceContext() {

            return enclosingContext.inferenceContext();

        }

        public DeferredAttrContext deferredAttrContext() {

            return enclosingContext.deferredAttrContext();

        }

    }

    /**

     * Check context to be used when evaluating assignment/return statements

     */

    CheckContext basicHandler = new CheckContext() {

        public void report(DiagnosticPosition pos, JCDiagnostic details) {

            log.error(pos, "prob.found.req", details);

        }

        public boolean compatible(Type found, Type req, Warner warn) {

            return types.isAssignable(found, req, warn);

        }

        public Warner checkWarner(DiagnosticPosition pos, Type found, Type req) {

            return convertWarner(pos, found, req);

        }

        public InferenceContext inferenceContext() {

            return infer.emptyContext;

        }

        public DeferredAttrContext deferredAttrContext() {

            return deferredAttr.emptyDeferredAttrContext;

        }

        @Override

        public String toString() {

            return "CheckContext: basicHandler";

        }

    };

    /** Check that a given type is assignable to a given proto-type.

     *  If it is, return the type, otherwise return errType.

     *  @param pos        Position to be used for error reporting.

     *  @param found      The type that was found.

     *  @param req        The type that was required.

     */

    public Type checkType(DiagnosticPosition pos, Type found, Type req) {

        return checkType(pos, found, req, basicHandler);

    }

    Type checkType(final DiagnosticPosition pos, final Type found, final Type req, final CheckContext checkContext) {

        final InferenceContext inferenceContext = checkContext.inferenceContext();

        if (inferenceContext.free(req) || inferenceContext.free(found)) {

            inferenceContext.addFreeTypeListener(List.of(req, found),

                    solvedContext -> checkType(pos, solvedContext.asInstType(found), solvedContext.asInstType(req), checkContext));

        }

        if (req.hasTag(ERROR))

            return req;

        if (req.hasTag(NONE))

            return found;

        if (found == null || checkContext.compatible(found, req, checkContext.checkWarner(pos, found, req))) {

            return found;

        } else {

            if (found.isNumeric() && req.isNumeric()) {

                checkContext.report(pos, diags.fragment("possible.loss.of.precision", found, req));

                return types.createErrorType(found);

            }

            checkContext.report(pos, diags.fragment("inconvertible.types", found, req));

            return types.createErrorType(found);

        }

    }

    /** Check that a given type can be cast to a given target type.

     *  Return the result of the cast.

     *  @param pos        Position to be used for error reporting.

     *  @param found      The type that is being cast.

     *  @param req        The target type of the cast.

     */

    Type checkCastable(DiagnosticPosition pos, Type found, Type req) {

        return checkCastable(pos, found, req, basicHandler);

    }

    Type checkCastable(DiagnosticPosition pos, Type found, Type req, CheckContext checkContext) {

        if (types.isCastable(found, req, castWarner(pos, found, req))) {

            return req;

        } else {

            checkContext.report(pos, diags.fragment("inconvertible.types", found, req));

            return types.createErrorType(found);

        }

    }

    /** Check for redundant casts (i.e. where source type is a subtype of target type)

     * The problem should only be reported for non-292 cast

     */

    public void checkRedundantCast(Env<AttrContext> env, final JCTypeCast tree) {

        if (!tree.type.isErroneous()

                && types.isSameType(tree.expr.type, tree.clazz.type)

                && !(ignoreAnnotatedCasts && TreeInfo.containsTypeAnnotation(tree.clazz))

                && !is292targetTypeCast(tree)) {

            deferredLintHandler.report(() -> {

                if (lint.isEnabled(LintCategory.CAST))

                    log.warning(LintCategory.CAST,

                            tree.pos(), "redundant.cast", tree.clazz.type);

            });

        }

    }

    //where

        private boolean is292targetTypeCast(JCTypeCast tree) {

            boolean is292targetTypeCast = false;

            JCExpression expr = TreeInfo.skipParens(tree.expr);

            if (expr.hasTag(APPLY)) {

                JCMethodInvocation apply = (JCMethodInvocation)expr;

                Symbol sym = TreeInfo.symbol(apply.meth);

                is292targetTypeCast = sym != null &&

                    sym.kind == MTH &&

                    (sym.flags() & HYPOTHETICAL) != 0;

            }

            return is292targetTypeCast;

        }

        private static final boolean ignoreAnnotatedCasts = true;

    /** Check that a type is within some bounds.

     *

     *  Used in TypeApply to verify that, e.g., X in {@code V<X>} is a valid

     *  type argument.

     *  @param a             The type that should be bounded by bs.

     *  @param bound         The bound.

     */

    private boolean checkExtends(Type a, Type bound) {

         if (a.isUnbound()) {

             return true;

         } else if (!a.hasTag(WILDCARD)) {

             a = types.cvarUpperBound(a);

             return types.isSubtype(a, bound);

         } else if (a.isExtendsBound()) {

             return types.isCastable(bound, types.wildUpperBound(a), types.noWarnings);

         } else if (a.isSuperBound()) {

             return !types.notSoftSubtype(types.wildLowerBound(a), bound);

         }

         return true;

     }

    /** Check that type is different from 'void'.

     *  @param pos           Position to be used for error reporting.

     *  @param t             The type to be checked.

     */

    Type checkNonVoid(DiagnosticPosition pos, Type t) {

        if (t.hasTag(VOID)) {

            log.error(pos, "void.not.allowed.here");

            return types.createErrorType(t);

        } else {

            return t;

        }

    }

    Type checkClassOrArrayType(DiagnosticPosition pos, Type t) {

        if (!t.hasTag(CLASS) && !t.hasTag(ARRAY) && !t.hasTag(ERROR)) {

            return typeTagError(pos,

                                diags.fragment("type.req.class.array"),

                                asTypeParam(t));

        } else {

            return t;

        }

    }

    /** Check that type is a class or interface type.

     *  @param pos           Position to be used for error reporting.

     *  @param t             The type to be checked.

     */

    Type checkClassType(DiagnosticPosition pos, Type t) {

        if (!t.hasTag(CLASS) && !t.hasTag(ERROR)) {

            return typeTagError(pos,

                                diags.fragment("type.req.class"),

                                asTypeParam(t));

        } else {

            return t;

        }

    }

    //where

        private Object asTypeParam(Type t) {

            return (t.hasTag(TYPEVAR))

                                    ? diags.fragment("type.parameter", t)

                                    : t;

        }

    /** Check that type is a valid qualifier for a constructor reference expression

     */

    Type checkConstructorRefType(DiagnosticPosition pos, Type t) {

        t = checkClassOrArrayType(pos, t);

        if (t.hasTag(CLASS)) {

            if ((t.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {

                log.error(pos, "abstract.cant.be.instantiated", t.tsym);

                t = types.createErrorType(t);

            } else if ((t.tsym.flags() & ENUM) != 0) {

                log.error(pos, "enum.cant.be.instantiated");

                t = types.createErrorType(t);

            } else {

                t = checkClassType(pos, t, true);

            }

        } else if (t.hasTag(ARRAY)) {

            if (!types.isReifiable(((ArrayType)t).elemtype)) {

                log.error(pos, "generic.array.creation");

                t = types.createErrorType(t);

            }

        }

        return t;

    }

    /** Check that type is a class or interface type.

     *  @param pos           Position to be used for error reporting.

     *  @param t             The type to be checked.

     *  @param noBounds    True if type bounds are illegal here.

     */

    Type checkClassType(DiagnosticPosition pos, Type t, boolean noBounds) {

        t = checkClassType(pos, t);

        if (noBounds && t.isParameterized()) {

            List<Type> args = t.getTypeArguments();

            while (args.nonEmpty()) {

                if (args.head.hasTag(WILDCARD))

                    return typeTagError(pos,

                                        diags.fragment("type.req.exact"),

                                        args.head);

                args = args.tail;

            }

        }

        return t;

    }

    /** Check that type is a reference type, i.e. a class, interface or array type

     *  or a type variable.

     *  @param pos           Position to be used for error reporting.

     *  @param t             The type to be checked.

     */

    Type checkRefType(DiagnosticPosition pos, Type t) {

        if (t.isReference())

            return t;

        else

            return typeTagError(pos,

                                diags.fragment("type.req.ref"),

                                t);

    }

    /** Check that each type is a reference type, i.e. a class, interface or array type

     *  or a type variable.

     *  @param trees         Original trees, used for error reporting.

     *  @param types         The types to be checked.

     */

    List<Type> checkRefTypes(List<JCExpression> trees, List<Type> types) {

        List<JCExpression> tl = trees;

        for (List<Type> l = types; l.nonEmpty(); l = l.tail) {

            l.head = checkRefType(tl.head.pos(), l.head);

            tl = tl.tail;

        }

        return types;

    }

    /** Check that type is a null or reference type.

     *  @param pos           Position to be used for error reporting.

     *  @param t             The type to be checked.

     */

    Type checkNullOrRefType(DiagnosticPosition pos, Type t) {

        if (t.isReference() || t.hasTag(BOT))

            return t;

        else

            return typeTagError(pos,

                                diags.fragment("type.req.ref"),

                                t);

    }

    /** Check that flag set does not contain elements of two conflicting sets. s

     *  Return true if it doesn't.

     *  @param pos           Position to be used for error reporting.

     *  @param flags         The set of flags to be checked.

     *  @param set1          Conflicting flags set #1.

     *  @param set2          Conflicting flags set #2.

     */

    boolean checkDisjoint(DiagnosticPosition pos, long flags, long set1, long set2) {

        if ((flags & set1) != 0 && (flags & set2) != 0) {

            log.error(pos,

                      "illegal.combination.of.modifiers",

                      asFlagSet(TreeInfo.firstFlag(flags & set1)),

                      asFlagSet(TreeInfo.firstFlag(flags & set2)));

            return false;

        } else

            return true;

    }

    /** Check that usage of diamond operator is correct (i.e. diamond should not

     * be used with non-generic classes or in anonymous class creation expressions)

     */

    Type checkDiamond(JCNewClass tree, Type t) {

        if (!TreeInfo.isDiamond(tree) ||

                t.isErroneous()) {

            return checkClassType(tree.clazz.pos(), t, true);

        } else {

            if (tree.def != null && !allowDiamondWithAnonymousClassCreation) {

                log.error(DiagnosticFlag.SOURCE_LEVEL, tree.clazz.pos(),

                        Errors.CantApplyDiamond1(t, Fragments.DiamondAndAnonClassNotSupportedInSource(source.name)));

            }

            if (t.tsym.type.getTypeArguments().isEmpty()) {

                log.error(tree.clazz.pos(),

                    "cant.apply.diamond.1",

                    t, diags.fragment("diamond.non.generic", t));

                return types.createErrorType(t);

            } else if (tree.typeargs != null &&

                    tree.typeargs.nonEmpty()) {

                log.error(tree.clazz.pos(),

                    "cant.apply.diamond.1",

                    t, diags.fragment("diamond.and.explicit.params", t));

                return types.createErrorType(t);

            } else {

                return t;

            }

        }

    }

    /** Check that the type inferred using the diamond operator does not contain

     *  non-denotable types such as captured types or intersection types.

     *  @param t the type inferred using the diamond operator

     *  @return  the (possibly empty) list of non-denotable types.

     */

    List<Type> checkDiamondDenotable(ClassType t) {

        ListBuffer<Type> buf = new ListBuffer<>();

        for (Type arg : t.allparams()) {

            if (!diamondTypeChecker.visit(arg, null)) {

                buf.append(arg);

            }

        }

        return buf.toList();

    }

        // where

        /** diamondTypeChecker: A type visitor that descends down the given type looking for non-denotable

         *  types. The visit methods return false as soon as a non-denotable type is encountered and true

         *  otherwise.

         */

        private static final Types.SimpleVisitor<Boolean, Void> diamondTypeChecker = new Types.SimpleVisitor<Boolean, Void>() {

            @Override

            public Boolean visitType(Type t, Void s) {

                return true;

            }

            @Override

            public Boolean visitClassType(ClassType t, Void s) {

                if (t.isCompound()) {

                    return false;

                }

                for (Type targ : t.allparams()) {

                    if (!visit(targ, s)) {

                        return false;

                    }

                }

                return true;

            }

            @Override

            public Boolean visitTypeVar(TypeVar t, Void s) {

                /* Any type variable mentioned in the inferred type must have been declared as a type parameter

                  (i.e cannot have been produced by inference (18.4))

                */

                return t.tsym.owner.type.getTypeArguments().contains(t);

            }

            @Override

            public Boolean visitCapturedType(CapturedType t, Void s) {

                /* Any type variable mentioned in the inferred type must have been declared as a type parameter

                  (i.e cannot have been produced by capture conversion (5.1.10))

                */

                return false;

            }

            @Override

            public Boolean visitArrayType(ArrayType t, Void s) {

                return visit(t.elemtype, s);

            }

            @Override

            public Boolean visitWildcardType(WildcardType t, Void s) {

                return visit(t.type, s);

            }

        };

    void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {

        MethodSymbol m = tree.sym;

        if (!allowSimplifiedVarargs) return;

        boolean hasTrustMeAnno = m.attribute(syms.trustMeType.tsym) != null;

        Type varargElemType = null;

        if (m.isVarArgs()) {

            varargElemType = types.elemtype(tree.params.last().type);

        }

        if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {

            if (varargElemType != null) {

                log.error(tree,

                        "varargs.invalid.trustme.anno",

                          syms.trustMeType.tsym,

                          allowPrivateSafeVarargs ?

                          diags.fragment("varargs.trustme.on.virtual.varargs", m) :

                          diags.fragment("varargs.trustme.on.virtual.varargs.final.only", m));

            } else {

                log.error(tree,

                            "varargs.invalid.trustme.anno",

                            syms.trustMeType.tsym,

                            diags.fragment("varargs.trustme.on.non.varargs.meth", m));

            }

        } else if (hasTrustMeAnno && varargElemType != null &&

                            types.isReifiable(varargElemType)) {

            warnUnsafeVararg(tree,

                            "varargs.redundant.trustme.anno",

                            syms.trustMeType.tsym,

                            diags.fragment("varargs.trustme.on.reifiable.varargs", varargElemType));

        }

        else if (!hasTrustMeAnno && varargElemType != null &&

                !types.isReifiable(varargElemType)) {

            warnUnchecked(tree.params.head.pos(), "unchecked.varargs.non.reifiable.type", varargElemType);

        }

    }

    //where

        private boolean isTrustMeAllowedOnMethod(Symbol s) {

            return (s.flags() & VARARGS) != 0 &&

                (s.isConstructor() ||

                    (s.flags() & (STATIC | FINAL |

                                  (allowPrivateSafeVarargs ? PRIVATE : 0) )) != 0);

        }

    Type checkMethod(final Type mtype,

            final Symbol sym,

            final Env<AttrContext> env,

            final List<JCExpression> argtrees,

            final List<Type> argtypes,

            final boolean useVarargs,

            InferenceContext inferenceContext) {

        // System.out.println("call   : " + env.tree);

        // System.out.println("method : " + owntype);

        // System.out.println("actuals: " + argtypes);

        if (inferenceContext.free(mtype)) {

            inferenceContext.addFreeTypeListener(List.of(mtype),

                    solvedContext -> checkMethod(solvedContext.asInstType(mtype), sym, env, argtrees, argtypes, useVarargs, solvedContext));

            return mtype;

        }

        Type owntype = mtype;

        List<Type> formals = owntype.getParameterTypes();

        List<Type> nonInferred = sym.type.getParameterTypes();

        if (nonInferred.length() != formals.length()) nonInferred = formals;

        Type last = useVarargs ? formals.last() : null;

        if (sym.name == names.init && sym.owner == syms.enumSym) {

            formals = formals.tail.tail;

            nonInferred = nonInferred.tail.tail;

        }

        List<JCExpression> args = argtrees;

        if (args != null) {

            //this is null when type-checking a method reference

            while (formals.head != last && args.head != null) {

                JCTree arg = args.head;

                Warner warn = convertWarner(arg.pos(), arg.type, nonInferred.head);

                assertConvertible(arg, arg.type, formals.head, warn);

                args = args.tail;

                formals = formals.tail;

                nonInferred = nonInferred.tail;

            }

            if (useVarargs) {

                Type varArg = types.elemtype(last);

                while (args.tail != null) {

                    JCTree arg = args.head;

                    Warner warn = convertWarner(arg.pos(), arg.type, varArg);

                    assertConvertible(arg, arg.type, varArg, warn);

                    args = args.tail;

                }

            } else if ((sym.flags() & (VARARGS | SIGNATURE_POLYMORPHIC)) == VARARGS) {

                // non-varargs call to varargs method