Validator(Env<AttrContext> env) 
{
            this.env = env;
}

  void checkRaw(JCTree tree,
    Env<AttrContext> env) 
{
            if (lint.isEnabled(LintCategory.RAW) &&
                tree.type.tag == CLASS &&
                !TreeInfo.isDiamond(tree) &&
                !env.enclClass.name.isEmpty() &&  //anonymous or intersection
                tree.type.isRaw()) {
                log.warning(LintCategory.RAW,
                        tree.pos(), "raw.class.use", tree.type, tree.type.tsym.type);
            }
}

 public  void validateTree(JCTree tree,
    boolean checkRaw,
    boolean isOuter) 
{
            try {
                if (tree != null) {
                    this.isOuter = isOuter;
                    tree.accept(this);
                    if (checkRaw)
                        checkRaw(tree, env);
                }
            } catch (CompletionFailure ex) {
                completionError(tree.pos(), ex);
            }
}

 public  void validateTrees(List<JCTree> trees,
    boolean checkRaw,
    boolean isOuter) 
{
            for (List< ? extends JCTree > l = trees; l.nonEmpty(); l = l.tail)
                validateTree(l.head, checkRaw, isOuter);
}

 public  void visitSelect(JCFieldAccess tree) 
{
            if (tree.type.tag == CLASS) {
                visitSelectInternal(tree);
                // Check that this type is either fully parameterized, or
                // not parameterized at all.
                if (tree.selected.type.isParameterized() && tree.type.tsym.type.getTypeArguments().nonEmpty())
                    log.error(tree.pos(), "improperly.formed.type.param.missing");
            }
}

 public  void visitSelectInternal(JCFieldAccess tree) 
{
            if (tree.type.tsym.isStatic() &&
                tree.selected.type.isParameterized()) {
                // The enclosing type is not a class, so we are
                // looking at a static member type.  However, the
                // qualifying expression is parameterized.
                log.error(tree.pos(), "cant.select.static.class.from.param.type");
            } else {
                // otherwise validate the rest of the expression
                tree.selected.accept(this);
            }
}

 public  void visitTree(JCTree tree) 
{

}

Default visitor method: do nothing.

 public  void visitTypeApply(JCTypeApply tree) 
{
            if (tree.type.tag == CLASS) {
                List< JCExpression > args = tree.arguments;
                List< Type > forms = tree.type.tsym.type.getTypeArguments();
                Type incompatibleArg = firstIncompatibleTypeArg(tree.type);
                if (incompatibleArg != null) {
                    for (JCTree arg : tree.arguments) {
                        if (arg.type == incompatibleArg) {
                            log.error(arg, "not.within.bounds", incompatibleArg, forms.head);
                        }
                        forms = forms.tail;
                     }
                 }
                forms = tree.type.tsym.type.getTypeArguments();
                boolean is_java_lang_Class = tree.type.tsym.flatName() == names.java_lang_Class;
                // For matching pairs of actual argument types `a' and
                // formal type parameters with declared bound `b' ...
                while (args.nonEmpty() && forms.nonEmpty()) {
                    validateTree(args.head,
                            !(isOuter && is_java_lang_Class),
                            false);
                    args = args.tail;
                    forms = forms.tail;
                }
                // Check that this type is either fully parameterized, or
                // not parameterized at all.
                if (tree.type.getEnclosingType().isRaw())
                    log.error(tree.pos(), "improperly.formed.type.inner.raw.param");
                if (tree.clazz.getTag() == JCTree.SELECT)
                    visitSelectInternal((JCFieldAccess)tree.clazz);
            }
}

 public  void visitTypeArray(JCArrayTypeTree tree) 
{
            tree.elemtype.accept(this);
}

 public  void visitTypeParameter(JCTypeParameter tree) 
{
            validateTrees(tree.bounds, true, isOuter);
            checkClassBounds(tree.pos(), tree.type);
}

 public  void visitWildcard(JCWildcard tree) 
{
            if (tree.inner != null)
                validateTree(tree.inner, true, isOuter);
}