Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java	Thu Oct 11 09:50:52 2012 -0700
     1.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java	Thu Oct 11 17:00:54 2012 -0700
     1.3 @@ -1,5 +1,5 @@
     1.4  /*
     1.5 - * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
     1.6 + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
     1.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     1.8   *
     1.9   * This code is free software; you can redistribute it and/or modify it
    1.10 @@ -195,10 +195,7 @@
    1.11          ClassUseWriter clsgen;
    1.12          String path = DirectoryManager.getDirectoryPath(classdoc.
    1.13                                                              containingPackage());
    1.14 -        if (path.length() > 0) {
    1.15 -            path += File.separator;
    1.16 -        }
    1.17 -        path += "class-use";
    1.18 +        path += "class-use" + DirectoryManager.URL_FILE_SEPARATOR;
    1.19          String filename = classdoc.name() + ".html";
    1.20          String pkgname = classdoc.containingPackage().name();
    1.21          pkgname += (pkgname.length() > 0)? ".class-use": "class-use";

     2.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/HelpWriter.java	Thu Oct 11 09:50:52 2012 -0700
     2.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/HelpWriter.java	Thu Oct 11 17:00:54 2012 -0700
     2.3 @@ -1,5 +1,5 @@
     2.4  /*
     2.5 - * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
     2.6 + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
     2.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     2.8   *
     2.9   * This code is free software; you can redistribute it and/or modify it
    2.10 @@ -302,7 +302,9 @@
    2.11          Content constHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
    2.12                  getResource("doclet.Constants_Summary"));
    2.13          Content liConst = HtmlTree.LI(HtmlStyle.blockList, constHead);
    2.14 -        Content line29 = getResource("doclet.Help_line_29");
    2.15 +        Content line29 = getResource("doclet.Help_line_29",
    2.16 +                getHyperLinkString("constant-values.html",
    2.17 +                configuration.getText("doclet.Constants_Summary")));
    2.18          Content constPara = HtmlTree.P(line29);
    2.19          liConst.addContent(constPara);
    2.20          ul.addContent(liConst);

     3.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties	Thu Oct 11 09:50:52 2012 -0700
     3.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties	Thu Oct 11 17:00:54 2012 -0700
     3.3 @@ -160,7 +160,7 @@
     3.4  doclet.Help_line_26=These links show and hide the HTML frames.  All pages are available with or without frames.
     3.5  doclet.Help_line_27=The {0} link shows all classes and interfaces except non-static nested types.
     3.6  doclet.Help_line_28=Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
     3.7 -doclet.Help_line_29=The <a href="constant-values.html">Constant Field Values</a> page lists the static final fields and their values.
     3.8 +doclet.Help_line_29=The {0} page lists the static final fields and their values.
     3.9  doclet.Help_line_30=This help file applies to API documentation generated using the standard doclet.
    3.10  doclet.Help_enum_line_1=Each enum has its own separate page with the following sections:
    3.11  doclet.Help_enum_line_2=Enum declaration

     4.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/Configuration.java	Thu Oct 11 09:50:52 2012 -0700
     4.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/Configuration.java	Thu Oct 11 17:00:54 2012 -0700
     4.3 @@ -488,17 +488,18 @@
     4.4      }
     4.5  
     4.6      /**
     4.7 -     * Add a traliling file separator, if not found or strip off extra trailing
     4.8 -     * file separators if any.
     4.9 +     * Add a trailing file separator, if not found. Remove superfluous
    4.10 +     * file separators if any. Preserve the front double file separator for
    4.11 +     * UNC paths.
    4.12       *
    4.13       * @param path Path under consideration.
    4.14       * @return String Properly constructed path string.
    4.15       */
    4.16 -    String addTrailingFileSep(String path) {
    4.17 +    public static String addTrailingFileSep(String path) {
    4.18          String fs = System.getProperty("file.separator");
    4.19          String dblfs = fs + fs;
    4.20          int indexDblfs;
    4.21 -        while ((indexDblfs = path.indexOf(dblfs)) >= 0) {
    4.22 +        while ((indexDblfs = path.indexOf(dblfs, 1)) >= 0) {
    4.23              path = path.substring(0, indexDblfs) +
    4.24                  path.substring(indexDblfs + fs.length());
    4.25          }

     5.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java	Thu Oct 11 09:50:52 2012 -0700
     5.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java	Thu Oct 11 17:00:54 2012 -0700
     5.3 @@ -262,11 +262,7 @@
     5.4                  urls[count++] = url;
     5.5              }
     5.6          }
     5.7 -        if (urls.length != count) {
     5.8 -            URL[] tmp = new URL[count];
     5.9 -            System.arraycopy(urls, 0, tmp, 0, count);
    5.10 -            urls = tmp;
    5.11 -        }
    5.12 +        urls = Arrays.copyOf(urls, count);
    5.13          return urls;
    5.14      }
    5.15  

     6.1 --- a/src/share/classes/com/sun/tools/javac/api/BasicJavacTask.java	Thu Oct 11 09:50:52 2012 -0700
     6.2 +++ b/src/share/classes/com/sun/tools/javac/api/BasicJavacTask.java	Thu Oct 11 17:00:54 2012 -0700
     6.3 @@ -136,4 +136,11 @@
     6.4          throw new IllegalStateException();
     6.5      }
     6.6  
     6.7 +    /**
     6.8 +     * For internal use only.  This method will be
     6.9 +     * removed without warning.
    6.10 +     */
    6.11 +    public void updateContext(Context newContext) {
    6.12 +        context = newContext;
    6.13 +    }
    6.14  }

     7.1 --- a/src/share/classes/com/sun/tools/javac/api/MultiTaskListener.java	Thu Oct 11 09:50:52 2012 -0700
     7.2 +++ b/src/share/classes/com/sun/tools/javac/api/MultiTaskListener.java	Thu Oct 11 17:00:54 2012 -0700
     7.3 @@ -79,10 +79,8 @@
     7.4              if (ccw.unwrap(l) == listener)
     7.5                  throw new IllegalStateException();
     7.6          }
     7.7 -        TaskListener[] newListeners = new TaskListener[listeners.length + 1];
     7.8 -        System.arraycopy(listeners, 0, newListeners, 0, listeners.length);
     7.9 -        newListeners[newListeners.length - 1] = ccw.wrap(listener);
    7.10 -        listeners = newListeners;
    7.11 +        listeners = Arrays.copyOf(listeners, listeners.length + 1);
    7.12 +        listeners[listeners.length - 1] = ccw.wrap(listener);
    7.13      }
    7.14  
    7.15      public void remove(TaskListener listener) {

     8.1 --- a/src/share/classes/com/sun/tools/javac/code/Kinds.java	Thu Oct 11 09:50:52 2012 -0700
     8.2 +++ b/src/share/classes/com/sun/tools/javac/code/Kinds.java	Thu Oct 11 17:00:54 2012 -0700
     8.3 @@ -28,6 +28,7 @@
     8.4  import java.util.EnumSet;
     8.5  import java.util.Locale;
     8.6  
     8.7 +import com.sun.source.tree.MemberReferenceTree;
     8.8  import com.sun.tools.javac.api.Formattable;
     8.9  import com.sun.tools.javac.api.Messages;
    8.10  
    8.11 @@ -85,11 +86,12 @@
    8.12      public static final int AMBIGUOUS    = ERRONEOUS+1; // ambiguous reference
    8.13      public static final int HIDDEN       = ERRONEOUS+2; // hidden method or field
    8.14      public static final int STATICERR    = ERRONEOUS+3; // nonstatic member from static context
    8.15 -    public static final int ABSENT_VAR   = ERRONEOUS+4; // missing variable
    8.16 -    public static final int WRONG_MTHS   = ERRONEOUS+5; // methods with wrong arguments
    8.17 -    public static final int WRONG_MTH    = ERRONEOUS+6; // one method with wrong arguments
    8.18 -    public static final int ABSENT_MTH   = ERRONEOUS+7; // missing method
    8.19 -    public static final int ABSENT_TYP   = ERRONEOUS+8; // missing type
    8.20 +    public static final int MISSING_ENCL = ERRONEOUS+4; // missing enclosing class
    8.21 +    public static final int ABSENT_VAR   = ERRONEOUS+5; // missing variable
    8.22 +    public static final int WRONG_MTHS   = ERRONEOUS+6; // methods with wrong arguments
    8.23 +    public static final int WRONG_MTH    = ERRONEOUS+7; // one method with wrong arguments
    8.24 +    public static final int ABSENT_MTH   = ERRONEOUS+8; // missing method
    8.25 +    public static final int ABSENT_TYP   = ERRONEOUS+9; // missing type
    8.26  
    8.27      public enum KindName implements Formattable {
    8.28          ANNOTATION("kindname.annotation"),
    8.29 @@ -140,6 +142,14 @@
    8.30          }
    8.31      }
    8.32  
    8.33 +    public static KindName kindName(MemberReferenceTree.ReferenceMode mode) {
    8.34 +        switch (mode) {
    8.35 +            case INVOKE: return KindName.METHOD;
    8.36 +            case NEW: return KindName.CONSTRUCTOR;
    8.37 +            default : throw new AssertionError("Unexpected mode: "+ mode);
    8.38 +        }
    8.39 +    }
    8.40 +
    8.41      /** A KindName representing a given symbol
    8.42       */
    8.43      public static KindName kindName(Symbol sym) {

     9.1 --- a/src/share/classes/com/sun/tools/javac/code/Printer.java	Thu Oct 11 09:50:52 2012 -0700
     9.2 +++ b/src/share/classes/com/sun/tools/javac/code/Printer.java	Thu Oct 11 17:00:54 2012 -0700
     9.3 @@ -30,6 +30,10 @@
     9.4  import com.sun.tools.javac.api.Messages;
     9.5  import com.sun.tools.javac.code.Type.*;
     9.6  import com.sun.tools.javac.code.Symbol.*;
     9.7 +import com.sun.tools.javac.comp.DeferredAttr.DeferredType;
     9.8 +import com.sun.tools.javac.tree.JCTree;
     9.9 +import com.sun.tools.javac.tree.Pretty;
    9.10 +import com.sun.tools.javac.util.Assert;
    9.11  import com.sun.tools.javac.util.List;
    9.12  import com.sun.tools.javac.util.ListBuffer;
    9.13  
    9.14 @@ -51,6 +55,8 @@
    9.15      List<Type> seenCaptured = List.nil();
    9.16      static final int PRIME = 997;  // largest prime less than 1000
    9.17  
    9.18 +    protected Printer() { }
    9.19 +
    9.20      /**
    9.21       * This method should be overriden in order to provide proper i18n support.
    9.22       *

    10.1 --- a/src/share/classes/com/sun/tools/javac/code/Source.java	Thu Oct 11 09:50:52 2012 -0700
    10.2 +++ b/src/share/classes/com/sun/tools/javac/code/Source.java	Thu Oct 11 17:00:54 2012 -0700
    10.3 @@ -194,6 +194,9 @@
    10.4      public boolean allowObjectToPrimitiveCast() {
    10.5          return compareTo(JDK1_7) >= 0;
    10.6      }
    10.7 +    public boolean allowPoly() {
    10.8 +        return compareTo(JDK1_8) >= 0;
    10.9 +    }
   10.10      public boolean allowLambda() {
   10.11          return compareTo(JDK1_8) >= 0;
   10.12      }

    11.1 --- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Thu Oct 11 09:50:52 2012 -0700
    11.2 +++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Thu Oct 11 17:00:54 2012 -0700
    11.3 @@ -168,6 +168,10 @@
    11.4          return owner;
    11.5      }
    11.6  
    11.7 +    public Symbol baseSymbol() {
    11.8 +        return this;
    11.9 +    }
   11.10 +
   11.11      /** The symbol's erased type.
   11.12       */
   11.13      public Type erasure(Types types) {
   11.14 @@ -918,7 +922,12 @@
   11.15          /** Clone this symbol with new owner.
   11.16           */
   11.17          public VarSymbol clone(Symbol newOwner) {
   11.18 -            VarSymbol v = new VarSymbol(flags_field, name, type, newOwner);
   11.19 +            VarSymbol v = new VarSymbol(flags_field, name, type, newOwner) {
   11.20 +                @Override
   11.21 +                public Symbol baseSymbol() {
   11.22 +                    return VarSymbol.this;
   11.23 +                }
   11.24 +            };
   11.25              v.pos = pos;
   11.26              v.adr = adr;
   11.27              v.data = data;
   11.28 @@ -1045,7 +1054,12 @@
   11.29          /** Clone this symbol with new owner.
   11.30           */
   11.31          public MethodSymbol clone(Symbol newOwner) {
   11.32 -            MethodSymbol m = new MethodSymbol(flags_field, name, type, newOwner);
   11.33 +            MethodSymbol m = new MethodSymbol(flags_field, name, type, newOwner) {
   11.34 +                @Override
   11.35 +                public Symbol baseSymbol() {
   11.36 +                    return MethodSymbol.this;
   11.37 +                }
   11.38 +            };
   11.39              m.code = code;
   11.40              return m;
   11.41          }
   11.42 @@ -1068,6 +1082,10 @@
   11.43              }
   11.44          }
   11.45  
   11.46 +        public boolean isDynamic() {
   11.47 +            return false;
   11.48 +        }
   11.49 +
   11.50          /** find a symbol that this (proxy method) symbol implements.
   11.51           *  @param    c       The class whose members are searched for
   11.52           *                    implementations
   11.53 @@ -1356,6 +1374,27 @@
   11.54          }
   11.55      }
   11.56  
   11.57 +    /** A class for invokedynamic method calls.
   11.58 +     */
   11.59 +    public static class DynamicMethodSymbol extends MethodSymbol {
   11.60 +
   11.61 +        public Object[] staticArgs;
   11.62 +        public Symbol bsm;
   11.63 +        public int bsmKind;
   11.64 +
   11.65 +        public DynamicMethodSymbol(Name name, Symbol owner, int bsmKind, MethodSymbol bsm, Type type, Object[] staticArgs) {
   11.66 +            super(0, name, type, owner);
   11.67 +            this.bsm = bsm;
   11.68 +            this.bsmKind = bsmKind;
   11.69 +            this.staticArgs = staticArgs;
   11.70 +        }
   11.71 +
   11.72 +        @Override
   11.73 +        public boolean isDynamic() {
   11.74 +            return true;
   11.75 +        }
   11.76 +    }
   11.77 +
   11.78      /** A class for predefined operators.
   11.79       */
   11.80      public static class OperatorSymbol extends MethodSymbol {

    12.1 --- a/src/share/classes/com/sun/tools/javac/code/Symtab.java	Thu Oct 11 09:50:52 2012 -0700
    12.2 +++ b/src/share/classes/com/sun/tools/javac/code/Symtab.java	Thu Oct 11 17:00:54 2012 -0700
    12.3 @@ -126,6 +126,7 @@
    12.4      public final Type cloneableType;
    12.5      public final Type serializableType;
    12.6      public final Type methodHandleType;
    12.7 +    public final Type methodTypeType;
    12.8      public final Type nativeHeaderType;
    12.9      public final Type throwableType;
   12.10      public final Type errorType;
   12.11 @@ -182,6 +183,10 @@
   12.12       */
   12.13      public final Name[] boxedName = new Name[TypeTags.TypeTagCount];
   12.14  
   12.15 +    /** A set containing all operator names.
   12.16 +     */
   12.17 +    public final Set<Name> operatorNames = new HashSet<Name>();
   12.18 +
   12.19      /** A hashtable containing the encountered top-level and member classes,
   12.20       *  indexed by flat names. The table does not contain local classes.
   12.21       *  It should be updated from the outside to reflect classes defined
   12.22 @@ -243,7 +248,7 @@
   12.23                              int opcode) {
   12.24          predefClass.members().enter(
   12.25              new OperatorSymbol(
   12.26 -                names.fromString(name),
   12.27 +                makeOperatorName(name),
   12.28                  new MethodType(List.of(left, right), res,
   12.29                                 List.<Type>nil(), methodClass),
   12.30                  opcode,
   12.31 @@ -274,7 +279,7 @@
   12.32                                       Type res,
   12.33                                       int opcode) {
   12.34          OperatorSymbol sym =
   12.35 -            new OperatorSymbol(names.fromString(name),
   12.36 +            new OperatorSymbol(makeOperatorName(name),
   12.37                                 new MethodType(List.of(arg),
   12.38                                                res,
   12.39                                                List.<Type>nil(),
   12.40 @@ -285,6 +290,16 @@
   12.41          return sym;
   12.42      }
   12.43  
   12.44 +    /**
   12.45 +     * Create a new operator name from corresponding String representation
   12.46 +     * and add the name to the set of known operator names.
   12.47 +     */
   12.48 +    private Name makeOperatorName(String name) {
   12.49 +        Name opName = names.fromString(name);
   12.50 +        operatorNames.add(opName);
   12.51 +        return opName;
   12.52 +    }
   12.53 +
   12.54      /** Enter a class into symbol table.
   12.55       *  @param    The name of the class.
   12.56       */
   12.57 @@ -440,6 +455,7 @@
   12.58          throwableType = enterClass("java.lang.Throwable");
   12.59          serializableType = enterClass("java.io.Serializable");
   12.60          methodHandleType = enterClass("java.lang.invoke.MethodHandle");
   12.61 +        methodTypeType = enterClass("java.lang.invoke.MethodType");
   12.62          errorType = enterClass("java.lang.Error");
   12.63          illegalArgumentExceptionType = enterClass("java.lang.IllegalArgumentException");
   12.64          interruptedExceptionType = enterClass("java.lang.InterruptedException");

    13.1 --- a/src/share/classes/com/sun/tools/javac/code/Type.java	Thu Oct 11 09:50:52 2012 -0700
    13.2 +++ b/src/share/classes/com/sun/tools/javac/code/Type.java	Thu Oct 11 17:00:54 2012 -0700
    13.3 @@ -27,14 +27,19 @@
    13.4  
    13.5  import java.util.Collections;
    13.6  
    13.7 +import com.sun.tools.javac.code.Symbol.*;
    13.8  import com.sun.tools.javac.util.*;
    13.9 -import com.sun.tools.javac.code.Symbol.*;
   13.10 +
   13.11 +import java.util.EnumMap;
   13.12 +import java.util.EnumSet;
   13.13 +import java.util.Map;
   13.14 +import java.util.Set;
   13.15  
   13.16  import javax.lang.model.type.*;
   13.17  
   13.18 +import static com.sun.tools.javac.code.BoundKind.*;
   13.19  import static com.sun.tools.javac.code.Flags.*;
   13.20  import static com.sun.tools.javac.code.Kinds.*;
   13.21 -import static com.sun.tools.javac.code.BoundKind.*;
   13.22  import static com.sun.tools.javac.code.TypeTags.*;
   13.23  
   13.24  /** This class represents Java types. The class itself defines the behavior of
   13.25 @@ -70,6 +75,9 @@
   13.26      /** Constant type: no type at all. */
   13.27      public static final JCNoType noType = new JCNoType(NONE);
   13.28  
   13.29 +    /** Constant type: special type to be used during recovery of deferred expressions. */
   13.30 +    public static final JCNoType recoveryType = new JCNoType(NONE);
   13.31 +
   13.32      /** If this switch is turned on, the names of type variables
   13.33       *  and anonymous classes are printed with hashcodes appended.
   13.34       */
   13.35 @@ -1168,22 +1176,59 @@
   13.36          }
   13.37      }
   13.38  
   13.39 -    /** A class for instantiatable variables, for use during type
   13.40 -     *  inference.
   13.41 +    /** A class for inference variables, for use during method/diamond type
   13.42 +     *  inference. An inference variable has upper/lower bounds and a set
   13.43 +     *  of equality constraints. Such bounds are set during subtyping, type-containment,
   13.44 +     *  type-equality checks, when the types being tested contain inference variables.
   13.45 +     *  A change listener can be attached to an inference variable, to receive notifications
   13.46 +     *  whenever the bounds of an inference variable change.
   13.47       */
   13.48      public static class UndetVar extends DelegatedType {
   13.49 -        public List<Type> lobounds = List.nil();
   13.50 -        public List<Type> hibounds = List.nil();
   13.51 -        public List<Type> eq = List.nil();
   13.52 +
   13.53 +        /** Inference variable change listener. The listener method is called
   13.54 +         *  whenever a change to the inference variable's bounds occurs
   13.55 +         */
   13.56 +        public interface UndetVarListener {
   13.57 +            /** called when some inference variable bounds (of given kinds ibs) change */
   13.58 +            void varChanged(UndetVar uv, Set<InferenceBound> ibs);
   13.59 +        }
   13.60 +
   13.61 +        /**
   13.62 +         * Inference variable bound kinds
   13.63 +         */
   13.64 +        public enum InferenceBound {
   13.65 +            /** upper bounds */
   13.66 +            UPPER,
   13.67 +            /** lower bounds */
   13.68 +            LOWER,
   13.69 +            /** equality constraints */
   13.70 +            EQ;
   13.71 +        }
   13.72 +
   13.73 +        /** inference variable bounds */
   13.74 +        private Map<InferenceBound, List<Type>> bounds;
   13.75 +
   13.76 +        /** inference variable's inferred type (set from Infer.java) */
   13.77          public Type inst = null;
   13.78  
   13.79 +        /** inference variable's change listener */
   13.80 +        public UndetVarListener listener = null;
   13.81 +
   13.82          @Override
   13.83          public <R,S> R accept(Type.Visitor<R,S> v, S s) {
   13.84              return v.visitUndetVar(this, s);
   13.85          }
   13.86  
   13.87 -        public UndetVar(Type origin) {
   13.88 +        public UndetVar(TypeVar origin, Types types) {
   13.89 +            this(origin, types, true);
   13.90 +        }
   13.91 +
   13.92 +        public UndetVar(TypeVar origin, Types types, boolean includeBounds) {
   13.93              super(UNDETVAR, origin);
   13.94 +            bounds = new EnumMap<InferenceBound, List<Type>>(InferenceBound.class);
   13.95 +            bounds.put(InferenceBound.UPPER, includeBounds ? types.getBounds(origin) : List.<Type>nil());
   13.96 +            bounds.put(InferenceBound.LOWER, List.<Type>nil());
   13.97 +            bounds.put(InferenceBound.EQ, List.<Type>nil());
   13.98          }
   13.99  
  13.100          public String toString() {
  13.101 @@ -1195,6 +1240,48 @@
  13.102              if (inst != null) return inst.baseType();
  13.103              else return this;
  13.104          }
  13.105 +
  13.106 +        /** get all bounds of a given kind */
  13.107 +        public List<Type> getBounds(InferenceBound ib) {
  13.108 +            return bounds.get(ib);
  13.109 +        }
  13.110 +
  13.111 +        /** add a bound of a given kind - this might trigger listener notification */
  13.112 +        public void addBound(InferenceBound ib, Type bound, Types types) {
  13.113 +            List<Type> prevBounds = bounds.get(ib);
  13.114 +            for (Type b : prevBounds) {
  13.115 +                if (types.isSameType(b, bound)) {
  13.116 +                    return;
  13.117 +                }
  13.118 +            }
  13.119 +            bounds.put(ib, prevBounds.prepend(bound));
  13.120 +            notifyChange(EnumSet.of(ib));
  13.121 +        }
  13.122 +
  13.123 +        /** replace types in all bounds - this might trigger listener notification */
  13.124 +        public void substBounds(List<Type> from, List<Type> to, Types types) {
  13.125 +            EnumSet<InferenceBound> changed = EnumSet.noneOf(InferenceBound.class);
  13.126 +            Map<InferenceBound, List<Type>> bounds2 = new EnumMap<InferenceBound, List<Type>>(InferenceBound.class);
  13.127 +            for (Map.Entry<InferenceBound, List<Type>> _entry : bounds.entrySet()) {
  13.128 +                InferenceBound ib = _entry.getKey();
  13.129 +                List<Type> prevBounds = _entry.getValue();
  13.130 +                List<Type> newBounds = types.subst(prevBounds, from, to);
  13.131 +                bounds2.put(ib, newBounds);
  13.132 +                if (prevBounds != newBounds) {
  13.133 +                    changed.add(ib);
  13.134 +                }
  13.135 +            }
  13.136 +            if (!changed.isEmpty()) {
  13.137 +                bounds = bounds2;
  13.138 +                notifyChange(changed);
  13.139 +            }
  13.140 +        }
  13.141 +
  13.142 +        private void notifyChange(EnumSet<InferenceBound> ibs) {
  13.143 +            if (listener != null) {
  13.144 +                listener.varChanged(this, ibs);
  13.145 +            }
  13.146 +        }
  13.147      }
  13.148  
  13.149      /** Represents VOID or NONE.

    14.1 --- a/src/share/classes/com/sun/tools/javac/code/TypeTags.java	Thu Oct 11 09:50:52 2012 -0700
    14.2 +++ b/src/share/classes/com/sun/tools/javac/code/TypeTags.java	Thu Oct 11 17:00:54 2012 -0700
    14.3 @@ -102,9 +102,13 @@
    14.4       */
    14.5      public static final int FORALL = WILDCARD+1;
    14.6  
    14.7 +    /** The tag of deferred expression types in method context
    14.8 +     */
    14.9 +    public static final int DEFERRED = FORALL+1;
   14.10 +
   14.11      /** The tag of the bottom type <null>.
   14.12       */
   14.13 -    public static final int BOT = FORALL+1;
   14.14 +    public static final int BOT = DEFERRED+1;
   14.15  
   14.16      /** The tag of a missing type.
   14.17       */

    15.1 --- a/src/share/classes/com/sun/tools/javac/code/Types.java	Thu Oct 11 09:50:52 2012 -0700
    15.2 +++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Thu Oct 11 17:00:54 2012 -0700
    15.3 @@ -34,6 +34,7 @@
    15.4  import com.sun.tools.javac.jvm.ClassReader;
    15.5  import com.sun.tools.javac.code.Attribute.RetentionPolicy;
    15.6  import com.sun.tools.javac.code.Lint.LintCategory;
    15.7 +import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
    15.8  import com.sun.tools.javac.comp.Check;
    15.9  
   15.10  import static com.sun.tools.javac.code.Scope.*;
   15.11 @@ -78,8 +79,10 @@
   15.12      final boolean allowObjectToPrimitiveCast;
   15.13      final ClassReader reader;
   15.14      final Check chk;
   15.15 +    JCDiagnostic.Factory diags;
   15.16      List<Warner> warnStack = List.nil();
   15.17      final Name capturedName;
   15.18 +    private final FunctionDescriptorLookupError functionDescriptorLookupError;
   15.19  
   15.20      // <editor-fold defaultstate="collapsed" desc="Instantiating">
   15.21      public static Types instance(Context context) {
   15.22 @@ -101,6 +104,8 @@
   15.23          chk = Check.instance(context);
   15.24          capturedName = names.fromString("<captured wildcard>");
   15.25          messages = JavacMessages.instance(context);
   15.26 +        diags = JCDiagnostic.Factory.instance(context);
   15.27 +        functionDescriptorLookupError = new FunctionDescriptorLookupError();
   15.28      }
   15.29      // </editor-fold>
   15.30  
   15.31 @@ -295,6 +300,294 @@
   15.32      }
   15.33      // </editor-fold>
   15.34  
   15.35 +    // <editor-fold defaultstate="collapsed" desc="findSam">
   15.36 +
   15.37 +    /**
   15.38 +     * Exception used to report a function descriptor lookup failure. The exception
   15.39 +     * wraps a diagnostic that can be used to generate more details error
   15.40 +     * messages.
   15.41 +     */
   15.42 +    public static class FunctionDescriptorLookupError extends RuntimeException {
   15.43 +        private static final long serialVersionUID = 0;
   15.44 +
   15.45 +        JCDiagnostic diagnostic;
   15.46 +
   15.47 +        FunctionDescriptorLookupError() {
   15.48 +            this.diagnostic = null;
   15.49 +        }
   15.50 +
   15.51 +        FunctionDescriptorLookupError setMessage(JCDiagnostic diag) {
   15.52 +            this.diagnostic = diag;
   15.53 +            return this;
   15.54 +        }
   15.55 +
   15.56 +        public JCDiagnostic getDiagnostic() {
   15.57 +            return diagnostic;
   15.58 +        }
   15.59 +    }
   15.60 +
   15.61 +    /**
   15.62 +     * A cache that keeps track of function descriptors associated with given
   15.63 +     * functional interfaces.
   15.64 +     */
   15.65 +    class DescriptorCache {
   15.66 +
   15.67 +        private WeakHashMap<TypeSymbol, Entry> _map = new WeakHashMap<TypeSymbol, Entry>();
   15.68 +
   15.69 +        class FunctionDescriptor {
   15.70 +            Symbol descSym;
   15.71 +
   15.72 +            FunctionDescriptor(Symbol descSym) {
   15.73 +                this.descSym = descSym;
   15.74 +            }
   15.75 +
   15.76 +            public Symbol getSymbol() {
   15.77 +                return descSym;
   15.78 +            }
   15.79 +
   15.80 +            public Type getType(Type origin) {
   15.81 +                return memberType(origin, descSym);
   15.82 +            }
   15.83 +        }
   15.84 +
   15.85 +        class Entry {
   15.86 +            final FunctionDescriptor cachedDescRes;
   15.87 +            final int prevMark;
   15.88 +
   15.89 +            public Entry(FunctionDescriptor cachedDescRes,
   15.90 +                    int prevMark) {
   15.91 +                this.cachedDescRes = cachedDescRes;
   15.92 +                this.prevMark = prevMark;
   15.93 +            }
   15.94 +
   15.95 +            boolean matches(int mark) {
   15.96 +                return  this.prevMark == mark;
   15.97 +            }
   15.98 +        }
   15.99 +
  15.100 +        FunctionDescriptor get(TypeSymbol origin) throws FunctionDescriptorLookupError {
  15.101 +            Entry e = _map.get(origin);
  15.102 +            CompoundScope members = membersClosure(origin.type, false);
  15.103 +            if (e == null ||
  15.104 +                    !e.matches(members.getMark())) {
  15.105 +                FunctionDescriptor descRes = findDescriptorInternal(origin, members);
  15.106 +                _map.put(origin, new Entry(descRes, members.getMark()));
  15.107 +                return descRes;
  15.108 +            }
  15.109 +            else {
  15.110 +                return e.cachedDescRes;
  15.111 +            }
  15.112 +        }
  15.113 +
  15.114 +        /**
  15.115 +         * Scope filter used to skip methods that should be ignored during
  15.116 +         * function interface conversion (such as methods overridden by
  15.117 +         * j.l.Object)
  15.118 +         */
  15.119 +        class DescriptorFilter implements Filter<Symbol> {
  15.120 +
  15.121 +            TypeSymbol origin;
  15.122 +
  15.123 +            DescriptorFilter(TypeSymbol origin) {
  15.124 +                this.origin = origin;
  15.125 +            }
  15.126 +
  15.127 +            @Override
  15.128 +            public boolean accepts(Symbol sym) {
  15.129 +                    return sym.kind == Kinds.MTH &&
  15.130 +                            (sym.flags() & ABSTRACT) != 0 &&
  15.131 +                            !overridesObjectMethod(origin, sym) &&
  15.132 +                            notOverridden(sym);
  15.133 +            }
  15.134 +
  15.135 +            private boolean notOverridden(Symbol msym) {
  15.136 +                Symbol impl = ((MethodSymbol)msym).implementation(origin, Types.this, false);
  15.137 +                return impl == null || (impl.flags() & ABSTRACT) != 0;
  15.138 +            }
  15.139 +        };
  15.140 +
  15.141 +        /**
  15.142 +         * Compute the function descriptor associated with a given functional interface
  15.143 +         */
  15.144 +        public FunctionDescriptor findDescriptorInternal(TypeSymbol origin, CompoundScope membersCache) throws FunctionDescriptorLookupError {
  15.145 +            if (!origin.isInterface()) {
  15.146 +                //t must be an interface
  15.147 +                throw failure("not.a.functional.intf");
  15.148 +            }
  15.149 +
  15.150 +            final ListBuffer<Symbol> abstracts = ListBuffer.lb();
  15.151 +            for (Symbol sym : membersCache.getElements(new DescriptorFilter(origin))) {
  15.152 +                Type mtype = memberType(origin.type, sym);
  15.153 +                if (abstracts.isEmpty() ||
  15.154 +                        (sym.name == abstracts.first().name &&
  15.155 +                        overrideEquivalent(mtype, memberType(origin.type, abstracts.first())))) {
  15.156 +                    abstracts.append(sym);
  15.157 +                } else {
  15.158 +                    //the target method(s) should be the only abstract members of t
  15.159 +                    throw failure("not.a.functional.intf.1",
  15.160 +                            diags.fragment("incompatible.abstracts", Kinds.kindName(origin), origin));
  15.161 +                }
  15.162 +            }
  15.163 +            if (abstracts.isEmpty()) {
  15.164 +                //t must define a suitable non-generic method
  15.165 +                throw failure("not.a.functional.intf.1",
  15.166 +                            diags.fragment("no.abstracts", Kinds.kindName(origin), origin));
  15.167 +            } else if (abstracts.size() == 1) {
  15.168 +                if (abstracts.first().type.tag == FORALL) {
  15.169 +                    throw failure("invalid.generic.desc.in.functional.intf",
  15.170 +                            abstracts.first(),
  15.171 +                            Kinds.kindName(origin),
  15.172 +                            origin);
  15.173 +                } else {
  15.174 +                    return new FunctionDescriptor(abstracts.first());
  15.175 +                }
  15.176 +            } else { // size > 1
  15.177 +                for (Symbol msym : abstracts) {
  15.178 +                    if (msym.type.tag == FORALL) {
  15.179 +                        throw failure("invalid.generic.desc.in.functional.intf",
  15.180 +                                abstracts.first(),
  15.181 +                                Kinds.kindName(origin),
  15.182 +                                origin);
  15.183 +                    }
  15.184 +                }
  15.185 +                FunctionDescriptor descRes = mergeDescriptors(origin, abstracts.toList());
  15.186 +                if (descRes == null) {
  15.187 +                    //we can get here if the functional interface is ill-formed
  15.188 +                    ListBuffer<JCDiagnostic> descriptors = ListBuffer.lb();
  15.189 +                    for (Symbol desc : abstracts) {
  15.190 +                        String key = desc.type.getThrownTypes().nonEmpty() ?
  15.191 +                                "descriptor.throws" : "descriptor";
  15.192 +                        descriptors.append(diags.fragment(key, desc.name,
  15.193 +                                desc.type.getParameterTypes(),
  15.194 +                                desc.type.getReturnType(),
  15.195 +                                desc.type.getThrownTypes()));
  15.196 +                    }
  15.197 +                    JCDiagnostic.MultilineDiagnostic incompatibleDescriptors =
  15.198 +                            new JCDiagnostic.MultilineDiagnostic(diags.fragment("incompatible.descs.in.functional.intf",
  15.199 +                            Kinds.kindName(origin), origin), descriptors.toList());
  15.200 +                    throw failure(incompatibleDescriptors);
  15.201 +                }
  15.202 +                return descRes;
  15.203 +            }
  15.204 +        }
  15.205 +
  15.206 +        /**
  15.207 +         * Compute a synthetic type for the target descriptor given a list
  15.208 +         * of override-equivalent methods in the functional interface type.
  15.209 +         * The resulting method type is a method type that is override-equivalent
  15.210 +         * and return-type substitutable with each method in the original list.
  15.211 +         */
  15.212 +        private FunctionDescriptor mergeDescriptors(TypeSymbol origin, List<Symbol> methodSyms) {
  15.213 +            //pick argument types - simply take the signature that is a
  15.214 +            //subsignature of all other signatures in the list (as per JLS 8.4.2)
  15.215 +            List<Symbol> mostSpecific = List.nil();
  15.216 +            outer: for (Symbol msym1 : methodSyms) {
  15.217 +                Type mt1 = memberType(origin.type, msym1);
  15.218 +                for (Symbol msym2 : methodSyms) {
  15.219 +                    Type mt2 = memberType(origin.type, msym2);
  15.220 +                    if (!isSubSignature(mt1, mt2)) {
  15.221 +                        continue outer;
  15.222 +                    }
  15.223 +                }
  15.224 +                mostSpecific = mostSpecific.prepend(msym1);
  15.225 +            }
  15.226 +            if (mostSpecific.isEmpty()) {
  15.227 +                return null;
  15.228 +            }
  15.229 +
  15.230 +
  15.231 +            //pick return types - this is done in two phases: (i) first, the most
  15.232 +            //specific return type is chosen using strict subtyping; if this fails,
  15.233 +            //a second attempt is made using return type substitutability (see JLS 8.4.5)
  15.234 +            boolean phase2 = false;
  15.235 +            Symbol bestSoFar = null;
  15.236 +            while (bestSoFar == null) {
  15.237 +                outer: for (Symbol msym1 : mostSpecific) {
  15.238 +                    Type mt1 = memberType(origin.type, msym1);
  15.239 +                    for (Symbol msym2 : methodSyms) {
  15.240 +                        Type mt2 = memberType(origin.type, msym2);
  15.241 +                        if (phase2 ?
  15.242 +                                !returnTypeSubstitutable(mt1, mt2) :
  15.243 +                                !isSubtypeInternal(mt1.getReturnType(), mt2.getReturnType())) {
  15.244 +                            continue outer;
  15.245 +                        }
  15.246 +                    }
  15.247 +                    bestSoFar = msym1;
  15.248 +                }
  15.249 +                if (phase2) {
  15.250 +                    break;
  15.251 +                } else {
  15.252 +                    phase2 = true;
  15.253 +                }
  15.254 +            }
  15.255 +            if (bestSoFar == null) return null;
  15.256 +
  15.257 +            //merge thrown types - form the intersection of all the thrown types in
  15.258 +            //all the signatures in the list
  15.259 +            List<Type> thrown = null;
  15.260 +            for (Symbol msym1 : methodSyms) {
  15.261 +                Type mt1 = memberType(origin.type, msym1);
  15.262 +                thrown = (thrown == null) ?
  15.263 +                    mt1.getThrownTypes() :
  15.264 +                    chk.intersect(mt1.getThrownTypes(), thrown);
  15.265 +            }
  15.266 +
  15.267 +            final List<Type> thrown1 = thrown;
  15.268 +            return new FunctionDescriptor(bestSoFar) {
  15.269 +                @Override
  15.270 +                public Type getType(Type origin) {
  15.271 +                    Type mt = memberType(origin, getSymbol());
  15.272 +                    return new MethodType(mt.getParameterTypes(), mt.getReturnType(), thrown1, syms.methodClass);
  15.273 +                }
  15.274 +            };
  15.275 +        }
  15.276 +
  15.277 +        boolean isSubtypeInternal(Type s, Type t) {
  15.278 +            return (s.isPrimitive() && t.isPrimitive()) ?
  15.279 +                    isSameType(t, s) :
  15.280 +                    isSubtype(s, t);
  15.281 +        }
  15.282 +
  15.283 +        FunctionDescriptorLookupError failure(String msg, Object... args) {
  15.284 +            return failure(diags.fragment(msg, args));
  15.285 +        }
  15.286 +
  15.287 +        FunctionDescriptorLookupError failure(JCDiagnostic diag) {
  15.288 +            return functionDescriptorLookupError.setMessage(diag);
  15.289 +        }
  15.290 +    }
  15.291 +
  15.292 +    private DescriptorCache descCache = new DescriptorCache();
  15.293 +
  15.294 +    /**
  15.295 +     * Find the method descriptor associated to this class symbol - if the
  15.296 +     * symbol 'origin' is not a functional interface, an exception is thrown.
  15.297 +     */
  15.298 +    public Symbol findDescriptorSymbol(TypeSymbol origin) throws FunctionDescriptorLookupError {
  15.299 +        return descCache.get(origin).getSymbol();
  15.300 +    }
  15.301 +
  15.302 +    /**
  15.303 +     * Find the type of the method descriptor associated to this class symbol -
  15.304 +     * if the symbol 'origin' is not a functional interface, an exception is thrown.
  15.305 +     */
  15.306 +    public Type findDescriptorType(Type origin) throws FunctionDescriptorLookupError {
  15.307 +        return descCache.get(origin.tsym).getType(origin);
  15.308 +    }
  15.309 +
  15.310 +    /**
  15.311 +     * Is given type a functional interface?
  15.312 +     */
  15.313 +    public boolean isFunctionalInterface(TypeSymbol tsym) {
  15.314 +        try {
  15.315 +            findDescriptorSymbol(tsym);
  15.316 +            return true;
  15.317 +        } catch (FunctionDescriptorLookupError ex) {
  15.318 +            return false;
  15.319 +        }
  15.320 +    }
  15.321 +    // </editor-fold>
  15.322 +
  15.323      // <editor-fold defaultstate="collapsed" desc="isSubtype">
  15.324      /**
  15.325       * Is t an unchecked subtype of s?
  15.326 @@ -510,7 +803,7 @@
  15.327                      return false;
  15.328                  }
  15.329  
  15.330 -                t.hibounds = t.hibounds.prepend(s);
  15.331 +                t.addBound(InferenceBound.UPPER, s, Types.this);
  15.332                  return true;
  15.333              }
  15.334  
  15.335 @@ -578,7 +871,7 @@
  15.336                  undet.qtype == s ||
  15.337                  s.tag == ERROR ||
  15.338                  s.tag == BOT) return true;
  15.339 -            undet.lobounds = undet.lobounds.prepend(s);
  15.340 +            undet.addBound(InferenceBound.LOWER, s, this);
  15.341              return true;
  15.342          }
  15.343          default:
  15.344 @@ -723,7 +1016,7 @@
  15.345                  if (t == s || t.qtype == s || s.tag == ERROR || s.tag == UNKNOWN)
  15.346                      return true;
  15.347  
  15.348 -                t.eq = t.eq.prepend(s);
  15.349 +                t.addBound(InferenceBound.EQ, s, Types.this);
  15.350  
  15.351                  return true;
  15.352              }
  15.353 @@ -735,19 +1028,6 @@
  15.354          };
  15.355      // </editor-fold>
  15.356  
  15.357 -    // <editor-fold defaultstate="collapsed" desc="fromUnknownFun">
  15.358 -    /**
  15.359 -     * A mapping that turns all unknown types in this type to fresh
  15.360 -     * unknown variables.
  15.361 -     */
  15.362 -    public Mapping fromUnknownFun = new Mapping("fromUnknownFun") {
  15.363 -            public Type apply(Type t) {
  15.364 -                if (t.tag == UNKNOWN) return new UndetVar(t);
  15.365 -                else return t.map(this);
  15.366 -            }
  15.367 -        };
  15.368 -    // </editor-fold>
  15.369 -
  15.370      // <editor-fold defaultstate="collapsed" desc="Contains Type">
  15.371      public boolean containedBy(Type t, Type s) {
  15.372          switch (t.tag) {
  15.373 @@ -759,12 +1039,12 @@
  15.374                      case UNBOUND: //similar to ? extends Object
  15.375                      case EXTENDS: {
  15.376                          Type bound = upperBound(s);
  15.377 -                        undetvar.hibounds = undetvar.hibounds.prepend(bound);
  15.378 +                        undetvar.addBound(InferenceBound.UPPER, bound, this);
  15.379                          break;
  15.380                      }
  15.381                      case SUPER: {
  15.382                          Type bound = lowerBound(s);
  15.383 -                        undetvar.lobounds = undetvar.lobounds.prepend(bound);
  15.384 +                        undetvar.addBound(InferenceBound.LOWER, bound, this);
  15.385                          break;
  15.386                      }
  15.387                  }
  15.388 @@ -1227,7 +1507,10 @@
  15.389       * Returns the lower bounds of the formals of a method.
  15.390       */
  15.391      public List<Type> lowerBoundArgtypes(Type t) {
  15.392 -        return map(t.getParameterTypes(), lowerBoundMapping);
  15.393 +        return lowerBounds(t.getParameterTypes());
  15.394 +    }
  15.395 +    public List<Type> lowerBounds(List<Type> ts) {
  15.396 +        return map(ts, lowerBoundMapping);
  15.397      }
  15.398      private final Mapping lowerBoundMapping = new Mapping("lowerBound") {
  15.399              public Type apply(Type t) {
  15.400 @@ -2019,6 +2302,15 @@
  15.401              hasSameArgs(t, erasure(s)) || hasSameArgs(erasure(t), s);
  15.402      }
  15.403  
  15.404 +    public boolean overridesObjectMethod(TypeSymbol origin, Symbol msym) {
  15.405 +        for (Scope.Entry e = syms.objectType.tsym.members().lookup(msym.name) ; e.scope != null ; e = e.next()) {
  15.406 +            if (msym.overrides(e.sym, origin, Types.this, true)) {
  15.407 +                return true;
  15.408 +            }
  15.409 +        }
  15.410 +        return false;
  15.411 +    }
  15.412 +
  15.413      // <editor-fold defaultstate="collapsed" desc="Determining method implementation in given site">
  15.414      class ImplementationCache {
  15.415  
  15.416 @@ -3166,6 +3458,14 @@
  15.417          }
  15.418          return Type.noType;
  15.419      }
  15.420 +
  15.421 +    /**
  15.422 +     * Return the unboxed type if 't' is a boxed class, otherwise return 't' itself.
  15.423 +     */
  15.424 +    public Type unboxedTypeOrType(Type t) {
  15.425 +        Type unboxedType = unboxedType(t);
  15.426 +        return unboxedType.tag == NONE ? t : unboxedType;
  15.427 +    }
  15.428      // </editor-fold>
  15.429  
  15.430      // <editor-fold defaultstate="collapsed" desc="Capture conversion">

    16.1 --- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Thu Oct 11 09:50:52 2012 -0700
    16.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Thu Oct 11 17:00:54 2012 -0700
    16.3 @@ -514,22 +514,6 @@
    16.4                        expectedType);
    16.5              fatalError = true;
    16.6          }
    16.7 -
    16.8 -        // validate that all other elements of containing type has defaults
    16.9 -        scope = targetContainerType.tsym.members();
   16.10 -        error = false;
   16.11 -        for(Symbol elm : scope.getElements()) {
   16.12 -            if (elm.name != names.value &&
   16.13 -                elm.kind == Kinds.MTH &&
   16.14 -                ((MethodSymbol)elm).defaultValue == null) {
   16.15 -                log.error(pos,
   16.16 -                          "invalid.containedby.annotation.elem.nondefault",
   16.17 -                          targetContainerType,
   16.18 -                          elm);
   16.19 -                containerValueSymbol = null;
   16.20 -                error = true;
   16.21 -            }
   16.22 -        }
   16.23          if (error) {
   16.24              fatalError = true;
   16.25          }

    17.1 --- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Oct 11 09:50:52 2012 -0700
    17.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Oct 11 17:00:54 2012 -0700
    17.3 @@ -25,12 +25,10 @@
    17.4  
    17.5  package com.sun.tools.javac.comp;
    17.6  
    17.7 -import java.util.*;
    17.8 -import java.util.Set;
    17.9 -import javax.lang.model.element.ElementKind;
   17.10 -import javax.tools.JavaFileObject;
   17.11 -
   17.12  import com.sun.tools.javac.code.*;
   17.13 +import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
   17.14 +import com.sun.tools.javac.comp.Infer.InferenceContext;
   17.15 +import com.sun.tools.javac.comp.Infer.InferenceContext.FreeTypeListener;
   17.16  import com.sun.tools.javac.jvm.*;
   17.17  import com.sun.tools.javac.tree.*;
   17.18  import com.sun.tools.javac.util.*;
   17.19 @@ -45,10 +43,16 @@
   17.20  import com.sun.tools.javac.comp.Check.CheckContext;
   17.21  
   17.22  import com.sun.source.tree.IdentifierTree;
   17.23 +import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
   17.24  import com.sun.source.tree.MemberSelectTree;
   17.25  import com.sun.source.tree.TreeVisitor;
   17.26  import com.sun.source.util.SimpleTreeVisitor;
   17.27  
   17.28 +import java.util.*;
   17.29 +import java.util.Set;
   17.30 +import javax.lang.model.element.ElementKind;
   17.31 +import javax.tools.JavaFileObject;
   17.32 +
   17.33  import static com.sun.tools.javac.code.Flags.*;
   17.34  import static com.sun.tools.javac.code.Flags.ANNOTATION;
   17.35  import static com.sun.tools.javac.code.Flags.BLOCK;
   17.36 @@ -80,7 +84,9 @@
   17.37      final Symtab syms;
   17.38      final Resolve rs;
   17.39      final Infer infer;
   17.40 +    final DeferredAttr deferredAttr;
   17.41      final Check chk;
   17.42 +    final Flow flow;
   17.43      final MemberEnter memberEnter;
   17.44      final TreeMaker make;
   17.45      final ConstFold cfolder;
   17.46 @@ -106,10 +112,12 @@
   17.47          syms = Symtab.instance(context);
   17.48          rs = Resolve.instance(context);
   17.49          chk = Check.instance(context);
   17.50 +        flow = Flow.instance(context);
   17.51          memberEnter = MemberEnter.instance(context);
   17.52          make = TreeMaker.instance(context);
   17.53          enter = Enter.instance(context);
   17.54          infer = Infer.instance(context);
   17.55 +        deferredAttr = DeferredAttr.instance(context);
   17.56          cfolder = ConstFold.instance(context);
   17.57          target = Target.instance(context);
   17.58          types = Types.instance(context);
   17.59 @@ -127,23 +135,31 @@
   17.60          allowCovariantReturns = source.allowCovariantReturns();
   17.61          allowAnonOuterThis = source.allowAnonOuterThis();
   17.62          allowStringsInSwitch = source.allowStringsInSwitch();
   17.63 +        allowPoly = source.allowPoly() && options.isSet("allowPoly");
   17.64 +        allowLambda = source.allowLambda();
   17.65          sourceName = source.name;
   17.66          relax = (options.isSet("-retrofit") ||
   17.67                   options.isSet("-relax"));
   17.68          findDiamonds = options.get("findDiamond") != null &&
   17.69                   source.allowDiamond();
   17.70          useBeforeDeclarationWarning = options.isSet("useBeforeDeclarationWarning");
   17.71 +        identifyLambdaCandidate = options.getBoolean("identifyLambdaCandidate", false);
   17.72  
   17.73          statInfo = new ResultInfo(NIL, Type.noType);
   17.74          varInfo = new ResultInfo(VAR, Type.noType);
   17.75          unknownExprInfo = new ResultInfo(VAL, Type.noType);
   17.76          unknownTypeInfo = new ResultInfo(TYP, Type.noType);
   17.77 +        recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);
   17.78      }
   17.79  
   17.80      /** Switch: relax some constraints for retrofit mode.
   17.81       */
   17.82      boolean relax;
   17.83  
   17.84 +    /** Switch: support target-typing inference
   17.85 +     */
   17.86 +    boolean allowPoly;
   17.87 +
   17.88      /** Switch: support generics?
   17.89       */
   17.90      boolean allowGenerics;
   17.91 @@ -164,6 +180,10 @@
   17.92       */
   17.93      boolean allowCovariantReturns;
   17.94  
   17.95 +    /** Switch: support lambda expressions ?
   17.96 +     */
   17.97 +    boolean allowLambda;
   17.98 +
   17.99      /** Switch: allow references to surrounding object from anonymous
  17.100       * objects during constructor call?
  17.101       */
  17.102 @@ -186,6 +206,12 @@
  17.103      boolean useBeforeDeclarationWarning;
  17.104  
  17.105      /**
  17.106 +     * Switch: generate warnings whenever an anonymous inner class that is convertible
  17.107 +     * to a lambda expression is found
  17.108 +     */
  17.109 +    boolean identifyLambdaCandidate;
  17.110 +
  17.111 +    /**
  17.112       * Switch: allow strings in switch?
  17.113       */
  17.114      boolean allowStringsInSwitch;
  17.115 @@ -207,15 +233,29 @@
  17.116       *  @param ownkind  The computed kind of the tree
  17.117       *  @param resultInfo  The expected result of the tree
  17.118       */
  17.119 -    Type check(JCTree tree, Type owntype, int ownkind, ResultInfo resultInfo) {
  17.120 +    Type check(final JCTree tree, final Type found, final int ownkind, final ResultInfo resultInfo) {
  17.121 +        InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();
  17.122 +        Type owntype = found;
  17.123          if (owntype.tag != ERROR && resultInfo.pt.tag != METHOD && resultInfo.pt.tag != FORALL) {
  17.124 -            if ((ownkind & ~resultInfo.pkind) == 0) {
  17.125 -                owntype = resultInfo.check(tree, owntype);
  17.126 +            if (inferenceContext.free(found)) {
  17.127 +                inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {
  17.128 +                    @Override
  17.129 +                    public void typesInferred(InferenceContext inferenceContext) {
  17.130 +                        ResultInfo pendingResult =
  17.131 +                                    resultInfo.dup(inferenceContext.asInstType(resultInfo.pt, types));
  17.132 +                        check(tree, inferenceContext.asInstType(found, types), ownkind, pendingResult);
  17.133 +                    }
  17.134 +                });
  17.135 +                return tree.type = resultInfo.pt;
  17.136              } else {
  17.137 -                log.error(tree.pos(), "unexpected.type",
  17.138 -                          kindNames(resultInfo.pkind),
  17.139 -                          kindName(ownkind));
  17.140 -                owntype = types.createErrorType(owntype);
  17.141 +                if ((ownkind & ~resultInfo.pkind) == 0) {
  17.142 +                    owntype = resultInfo.check(tree, owntype);
  17.143 +                } else {
  17.144 +                    log.error(tree.pos(), "unexpected.type",
  17.145 +                            kindNames(resultInfo.pkind),
  17.146 +                            kindName(ownkind));
  17.147 +                    owntype = types.createErrorType(owntype);
  17.148 +                }
  17.149              }
  17.150          }
  17.151          tree.type = owntype;
  17.152 @@ -262,6 +302,9 @@
  17.153                  case CLASSDEF:
  17.154                      //class def is always an owner
  17.155                      return ((JCClassDecl)env.tree).sym;
  17.156 +                case LAMBDA:
  17.157 +                    //a lambda is an owner - return a fresh synthetic method symbol
  17.158 +                    return new MethodSymbol(0, names.empty, null, syms.methodClass);
  17.159                  case BLOCK:
  17.160                      //static/instance init blocks are owner
  17.161                      Symbol blockSym = env.info.scope.owner;
  17.162 @@ -297,8 +340,6 @@
  17.163              } else {
  17.164                  log.error(pos, "cant.assign.val.to.final.var", v);
  17.165              }
  17.166 -        } else if ((v.flags() & EFFECTIVELY_FINAL) != 0) {
  17.167 -            v.flags_field &= ~EFFECTIVELY_FINAL;
  17.168          }
  17.169      }
  17.170  
  17.171 @@ -431,14 +472,38 @@
  17.172          static final long serialVersionUID = -6924771130405446405L;
  17.173          private Env<AttrContext> env;
  17.174          private BreakAttr(Env<AttrContext> env) {
  17.175 -            this.env = env;
  17.176 +            this.env = copyEnv(env);
  17.177 +        }
  17.178 +
  17.179 +        private Env<AttrContext> copyEnv(Env<AttrContext> env) {
  17.180 +            Env<AttrContext> newEnv =
  17.181 +                    env.dup(env.tree, env.info.dup(copyScope(env.info.scope)));
  17.182 +            if (newEnv.outer != null) {
  17.183 +                newEnv.outer = copyEnv(newEnv.outer);
  17.184 +            }
  17.185 +            return newEnv;
  17.186 +        }
  17.187 +
  17.188 +        private Scope copyScope(Scope sc) {
  17.189 +            Scope newScope = new Scope(sc.owner);
  17.190 +            List<Symbol> elemsList = List.nil();
  17.191 +            while (sc != null) {
  17.192 +                for (Scope.Entry e = sc.elems ; e != null ; e = e.sibling) {
  17.193 +                    elemsList = elemsList.prepend(e.sym);
  17.194 +                }
  17.195 +                sc = sc.next;
  17.196 +            }
  17.197 +            for (Symbol s : elemsList) {
  17.198 +                newScope.enter(s);
  17.199 +            }
  17.200 +            return newScope;
  17.201          }
  17.202      }
  17.203  
  17.204      class ResultInfo {
  17.205 -        int pkind;
  17.206 -        Type pt;
  17.207 -        CheckContext checkContext;
  17.208 +        final int pkind;
  17.209 +        final Type pt;
  17.210 +        final CheckContext checkContext;
  17.211  
  17.212          ResultInfo(int pkind, Type pt) {
  17.213              this(pkind, pt, chk.basicHandler);
  17.214 @@ -450,15 +515,45 @@
  17.215              this.checkContext = checkContext;
  17.216          }
  17.217  
  17.218 -        protected Type check(DiagnosticPosition pos, Type found) {
  17.219 +        protected Type check(final DiagnosticPosition pos, final Type found) {
  17.220              return chk.checkType(pos, found, pt, checkContext);
  17.221          }
  17.222 +
  17.223 +        protected ResultInfo dup(Type newPt) {
  17.224 +            return new ResultInfo(pkind, newPt, checkContext);
  17.225 +        }
  17.226      }
  17.227  
  17.228 -    private final ResultInfo statInfo;
  17.229 -    private final ResultInfo varInfo;
  17.230 -    private final ResultInfo unknownExprInfo;
  17.231 -    private final ResultInfo unknownTypeInfo;
  17.232 +    class RecoveryInfo extends ResultInfo {
  17.233 +
  17.234 +        public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext) {
  17.235 +            super(Kinds.VAL, Type.recoveryType, new Check.NestedCheckContext(chk.basicHandler) {
  17.236 +                @Override
  17.237 +                public DeferredAttr.DeferredAttrContext deferredAttrContext() {
  17.238 +                    return deferredAttrContext;
  17.239 +                }
  17.240 +                @Override
  17.241 +                public boolean compatible(Type found, Type req, Warner warn) {
  17.242 +                    return true;
  17.243 +                }
  17.244 +                @Override
  17.245 +                public void report(DiagnosticPosition pos, JCDiagnostic details) {
  17.246 +                    //do nothing
  17.247 +                }
  17.248 +            });
  17.249 +        }
  17.250 +
  17.251 +        @Override
  17.252 +        protected Type check(DiagnosticPosition pos, Type found) {
  17.253 +            return chk.checkNonVoid(pos, super.check(pos, found));
  17.254 +        }
  17.255 +    }
  17.256 +
  17.257 +    final ResultInfo statInfo;
  17.258 +    final ResultInfo varInfo;
  17.259 +    final ResultInfo unknownExprInfo;
  17.260 +    final ResultInfo unknownTypeInfo;
  17.261 +    final ResultInfo recoveryInfo;
  17.262  
  17.263      Type pt() {
  17.264          return resultInfo.pt;
  17.265 @@ -491,7 +586,7 @@
  17.266       *  @param env     The environment visitor argument.
  17.267       *  @param resultInfo   The result info visitor argument.
  17.268       */
  17.269 -    private Type attribTree(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
  17.270 +    Type attribTree(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
  17.271          Env<AttrContext> prevEnv = this.env;
  17.272          ResultInfo prevResult = this.resultInfo;
  17.273          try {
  17.274 @@ -563,9 +658,12 @@
  17.275       */
  17.276      List<Type> attribArgs(List<JCExpression> trees, Env<AttrContext> env) {
  17.277          ListBuffer<Type> argtypes = new ListBuffer<Type>();
  17.278 -        for (List<JCExpression> l = trees; l.nonEmpty(); l = l.tail)
  17.279 -            argtypes.append(chk.checkNonVoid(
  17.280 -                l.head.pos(), types.upperBound(attribExpr(l.head, env, Infer.anyPoly))));
  17.281 +        for (JCExpression arg : trees) {
  17.282 +            Type argtype = allowPoly && TreeInfo.isPoly(arg, env.tree) ?
  17.283 +                    deferredAttr.new DeferredType(arg, env) :
  17.284 +                    chk.checkNonVoid(arg, attribExpr(arg, env, Infer.anyPoly));
  17.285 +            argtypes.append(argtype);
  17.286 +        }
  17.287          return argtypes.toList();
  17.288      }
  17.289  
  17.290 @@ -934,7 +1032,10 @@
  17.291              chk.checkDeprecatedAnnotation(tree.pos(), v);
  17.292  
  17.293              if (tree.init != null) {
  17.294 -                if ((v.flags_field & FINAL) != 0 && !tree.init.hasTag(NEWCLASS)) {
  17.295 +                if ((v.flags_field & FINAL) != 0 &&
  17.296 +                        !tree.init.hasTag(NEWCLASS) &&
  17.297 +                        !tree.init.hasTag(LAMBDA) &&
  17.298 +                        !tree.init.hasTag(REFERENCE)) {
  17.299                      // In this case, `v' is final.  Ensure that it's initializer is
  17.300                      // evaluated.
  17.301                      v.getConstValue(); // ensure initializer is evaluated
  17.302 @@ -979,8 +1080,11 @@
  17.303              // Create a new local environment with a local scope.
  17.304              Env<AttrContext> localEnv =
  17.305                  env.dup(tree, env.info.dup(env.info.scope.dup()));
  17.306 -            attribStats(tree.stats, localEnv);
  17.307 -            localEnv.info.scope.leave();
  17.308 +            try {
  17.309 +                attribStats(tree.stats, localEnv);
  17.310 +            } finally {
  17.311 +                localEnv.info.scope.leave();
  17.312 +            }
  17.313          }
  17.314          result = null;
  17.315      }
  17.316 @@ -1000,43 +1104,51 @@
  17.317      public void visitForLoop(JCForLoop tree) {
  17.318          Env<AttrContext> loopEnv =
  17.319              env.dup(env.tree, env.info.dup(env.info.scope.dup()));
  17.320 -        attribStats(tree.init, loopEnv);
  17.321 -        if (tree.cond != null) attribExpr(tree.cond, loopEnv, syms.booleanType);
  17.322 -        loopEnv.tree = tree; // before, we were not in loop!
  17.323 -        attribStats(tree.step, loopEnv);
  17.324 -        attribStat(tree.body, loopEnv);
  17.325 -        loopEnv.info.scope.leave();
  17.326 -        result = null;
  17.327 +        try {
  17.328 +            attribStats(tree.init, loopEnv);
  17.329 +            if (tree.cond != null) attribExpr(tree.cond, loopEnv, syms.booleanType);
  17.330 +            loopEnv.tree = tree; // before, we were not in loop!
  17.331 +            attribStats(tree.step, loopEnv);
  17.332 +            attribStat(tree.body, loopEnv);
  17.333 +            result = null;
  17.334 +        }
  17.335 +        finally {
  17.336 +            loopEnv.info.scope.leave();
  17.337 +        }
  17.338      }
  17.339  
  17.340      public void visitForeachLoop(JCEnhancedForLoop tree) {
  17.341          Env<AttrContext> loopEnv =
  17.342              env.dup(env.tree, env.info.dup(env.info.scope.dup()));
  17.343 -        attribStat(tree.var, loopEnv);
  17.344 -        Type exprType = types.upperBound(attribExpr(tree.expr, loopEnv));
  17.345 -        chk.checkNonVoid(tree.pos(), exprType);
  17.346 -        Type elemtype = types.elemtype(exprType); // perhaps expr is an array?
  17.347 -        if (elemtype == null) {
  17.348 -            // or perhaps expr implements Iterable<T>?
  17.349 -            Type base = types.asSuper(exprType, syms.iterableType.tsym);
  17.350 -            if (base == null) {
  17.351 -                log.error(tree.expr.pos(),
  17.352 -                        "foreach.not.applicable.to.type",
  17.353 -                        exprType,
  17.354 -                        diags.fragment("type.req.array.or.iterable"));
  17.355 -                elemtype = types.createErrorType(exprType);
  17.356 -            } else {
  17.357 -                List<Type> iterableParams = base.allparams();
  17.358 -                elemtype = iterableParams.isEmpty()
  17.359 -                    ? syms.objectType
  17.360 -                    : types.upperBound(iterableParams.head);
  17.361 +        try {
  17.362 +            attribStat(tree.var, loopEnv);
  17.363 +            Type exprType = types.upperBound(attribExpr(tree.expr, loopEnv));
  17.364 +            chk.checkNonVoid(tree.pos(), exprType);
  17.365 +            Type elemtype = types.elemtype(exprType); // perhaps expr is an array?
  17.366 +            if (elemtype == null) {
  17.367 +                // or perhaps expr implements Iterable<T>?
  17.368 +                Type base = types.asSuper(exprType, syms.iterableType.tsym);
  17.369 +                if (base == null) {
  17.370 +                    log.error(tree.expr.pos(),
  17.371 +                            "foreach.not.applicable.to.type",
  17.372 +                            exprType,
  17.373 +                            diags.fragment("type.req.array.or.iterable"));
  17.374 +                    elemtype = types.createErrorType(exprType);
  17.375 +                } else {
  17.376 +                    List<Type> iterableParams = base.allparams();
  17.377 +                    elemtype = iterableParams.isEmpty()
  17.378 +                        ? syms.objectType
  17.379 +                        : types.upperBound(iterableParams.head);
  17.380 +                }
  17.381              }
  17.382 +            chk.checkType(tree.expr.pos(), elemtype, tree.var.sym.type);
  17.383 +            loopEnv.tree = tree; // before, we were not in loop!
  17.384 +            attribStat(tree.body, loopEnv);
  17.385 +            result = null;
  17.386          }
  17.387 -        chk.checkType(tree.expr.pos(), elemtype, tree.var.sym.type);
  17.388 -        loopEnv.tree = tree; // before, we were not in loop!
  17.389 -        attribStat(tree.body, loopEnv);
  17.390 -        loopEnv.info.scope.leave();
  17.391 -        result = null;
  17.392 +        finally {
  17.393 +            loopEnv.info.scope.leave();
  17.394 +        }
  17.395      }
  17.396  
  17.397      public void visitLabelled(JCLabeledStatement tree) {
  17.398 @@ -1062,61 +1174,69 @@
  17.399          Env<AttrContext> switchEnv =
  17.400              env.dup(tree, env.info.dup(env.info.scope.dup()));
  17.401  
  17.402 -        boolean enumSwitch =
  17.403 -            allowEnums &&
  17.404 -            (seltype.tsym.flags() & Flags.ENUM) != 0;
  17.405 -        boolean stringSwitch = false;
  17.406 -        if (types.isSameType(seltype, syms.stringType)) {
  17.407 -            if (allowStringsInSwitch) {
  17.408 -                stringSwitch = true;
  17.409 -            } else {
  17.410 -                log.error(tree.selector.pos(), "string.switch.not.supported.in.source", sourceName);
  17.411 +        try {
  17.412 +
  17.413 +            boolean enumSwitch =
  17.414 +                allowEnums &&
  17.415 +                (seltype.tsym.flags() & Flags.ENUM) != 0;
  17.416 +            boolean stringSwitch = false;
  17.417 +            if (types.isSameType(seltype, syms.stringType)) {
  17.418 +                if (allowStringsInSwitch) {
  17.419 +                    stringSwitch = true;
  17.420 +                } else {
  17.421 +                    log.error(tree.selector.pos(), "string.switch.not.supported.in.source", sourceName);
  17.422 +                }
  17.423              }
  17.424 +            if (!enumSwitch && !stringSwitch)
  17.425 +                seltype = chk.checkType(tree.selector.pos(), seltype, syms.intType);
  17.426 +
  17.427 +            // Attribute all cases and
  17.428 +            // check that there are no duplicate case labels or default clauses.
  17.429 +            Set<Object> labels = new HashSet<Object>(); // The set of case labels.
  17.430 +            boolean hasDefault = false;      // Is there a default label?
  17.431 +            for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
  17.432 +                JCCase c = l.head;
  17.433 +                Env<AttrContext> caseEnv =
  17.434 +                    switchEnv.dup(c, env.info.dup(switchEnv.info.scope.dup()));
  17.435 +                try {
  17.436 +                    if (c.pat != null) {
  17.437 +                        if (enumSwitch) {
  17.438 +                            Symbol sym = enumConstant(c.pat, seltype);
  17.439 +                            if (sym == null) {
  17.440 +                                log.error(c.pat.pos(), "enum.label.must.be.unqualified.enum");
  17.441 +                            } else if (!labels.add(sym)) {
  17.442 +                                log.error(c.pos(), "duplicate.case.label");
  17.443 +                            }
  17.444 +                        } else {
  17.445 +                            Type pattype = attribExpr(c.pat, switchEnv, seltype);
  17.446 +                            if (pattype.tag != ERROR) {
  17.447 +                                if (pattype.constValue() == null) {
  17.448 +                                    log.error(c.pat.pos(),
  17.449 +                                              (stringSwitch ? "string.const.req" : "const.expr.req"));
  17.450 +                                } else if (labels.contains(pattype.constValue())) {
  17.451 +                                    log.error(c.pos(), "duplicate.case.label");
  17.452 +                                } else {
  17.453 +                                    labels.add(pattype.constValue());
  17.454 +                                }
  17.455 +                            }
  17.456 +                        }
  17.457 +                    } else if (hasDefault) {
  17.458 +                        log.error(c.pos(), "duplicate.default.label");
  17.459 +                    } else {
  17.460 +                        hasDefault = true;
  17.461 +                    }
  17.462 +                    attribStats(c.stats, caseEnv);
  17.463 +                } finally {
  17.464 +                    caseEnv.info.scope.leave();
  17.465 +                    addVars(c.stats, switchEnv.info.scope);
  17.466 +                }
  17.467 +            }
  17.468 +
  17.469 +            result = null;
  17.470          }
  17.471 -        if (!enumSwitch && !stringSwitch)
  17.472 -            seltype = chk.checkType(tree.selector.pos(), seltype, syms.intType);
  17.473 -
  17.474 -        // Attribute all cases and
  17.475 -        // check that there are no duplicate case labels or default clauses.
  17.476 -        Set<Object> labels = new HashSet<Object>(); // The set of case labels.
  17.477 -        boolean hasDefault = false;      // Is there a default label?
  17.478 -        for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
  17.479 -            JCCase c = l.head;
  17.480 -            Env<AttrContext> caseEnv =
  17.481 -                switchEnv.dup(c, env.info.dup(switchEnv.info.scope.dup()));
  17.482 -            if (c.pat != null) {
  17.483 -                if (enumSwitch) {
  17.484 -                    Symbol sym = enumConstant(c.pat, seltype);
  17.485 -                    if (sym == null) {
  17.486 -                        log.error(c.pat.pos(), "enum.label.must.be.unqualified.enum");
  17.487 -                    } else if (!labels.add(sym)) {
  17.488 -                        log.error(c.pos(), "duplicate.case.label");
  17.489 -                    }
  17.490 -                } else {
  17.491 -                    Type pattype = attribExpr(c.pat, switchEnv, seltype);
  17.492 -                    if (pattype.tag != ERROR) {
  17.493 -                        if (pattype.constValue() == null) {
  17.494 -                            log.error(c.pat.pos(),
  17.495 -                                      (stringSwitch ? "string.const.req" : "const.expr.req"));
  17.496 -                        } else if (labels.contains(pattype.constValue())) {
  17.497 -                            log.error(c.pos(), "duplicate.case.label");
  17.498 -                        } else {
  17.499 -                            labels.add(pattype.constValue());
  17.500 -                        }
  17.501 -                    }
  17.502 -                }
  17.503 -            } else if (hasDefault) {
  17.504 -                log.error(c.pos(), "duplicate.default.label");
  17.505 -            } else {
  17.506 -                hasDefault = true;
  17.507 -            }
  17.508 -            attribStats(c.stats, caseEnv);
  17.509 -            caseEnv.info.scope.leave();
  17.510 -            addVars(c.stats, switchEnv.info.scope);
  17.511 +        finally {
  17.512 +            switchEnv.info.scope.leave();
  17.513          }
  17.514 -
  17.515 -        switchEnv.info.scope.leave();
  17.516 -        result = null;
  17.517      }
  17.518      // where
  17.519          /** Add any variables defined in stats to the switch scope. */
  17.520 @@ -1158,63 +1278,72 @@
  17.521      public void visitTry(JCTry tree) {
  17.522          // Create a new local environment with a local
  17.523          Env<AttrContext> localEnv = env.dup(tree, env.info.dup(env.info.scope.dup()));
  17.524 -        boolean isTryWithResource = tree.resources.nonEmpty();
  17.525 -        // Create a nested environment for attributing the try block if needed
  17.526 -        Env<AttrContext> tryEnv = isTryWithResource ?
  17.527 -            env.dup(tree, localEnv.info.dup(localEnv.info.scope.dup())) :
  17.528 -            localEnv;
  17.529 -        // Attribute resource declarations
  17.530 -        for (JCTree resource : tree.resources) {
  17.531 -            CheckContext twrContext = new Check.NestedCheckContext(resultInfo.checkContext) {
  17.532 -                @Override
  17.533 -                public void report(DiagnosticPosition pos, JCDiagnostic details) {
  17.534 -                    chk.basicHandler.report(pos, diags.fragment("try.not.applicable.to.type", details));
  17.535 +        try {
  17.536 +            boolean isTryWithResource = tree.resources.nonEmpty();
  17.537 +            // Create a nested environment for attributing the try block if needed
  17.538 +            Env<AttrContext> tryEnv = isTryWithResource ?
  17.539 +                env.dup(tree, localEnv.info.dup(localEnv.info.scope.dup())) :
  17.540 +                localEnv;
  17.541 +            try {
  17.542 +                // Attribute resource declarations
  17.543 +                for (JCTree resource : tree.resources) {
  17.544 +                    CheckContext twrContext = new Check.NestedCheckContext(resultInfo.checkContext) {
  17.545 +                        @Override
  17.546 +                        public void report(DiagnosticPosition pos, JCDiagnostic details) {
  17.547 +                            chk.basicHandler.report(pos, diags.fragment("try.not.applicable.to.type", details));
  17.548 +                        }
  17.549 +                    };
  17.550 +                    ResultInfo twrResult = new ResultInfo(VAL, syms.autoCloseableType, twrContext);
  17.551 +                    if (resource.hasTag(VARDEF)) {
  17.552 +                        attribStat(resource, tryEnv);
  17.553 +                        twrResult.check(resource, resource.type);
  17.554 +
  17.555 +                        //check that resource type cannot throw InterruptedException
  17.556 +                        checkAutoCloseable(resource.pos(), localEnv, resource.type);
  17.557 +
  17.558 +                        VarSymbol var = (VarSymbol)TreeInfo.symbolFor(resource);
  17.559 +                        var.setData(ElementKind.RESOURCE_VARIABLE);
  17.560 +                    } else {
  17.561 +                        attribTree(resource, tryEnv, twrResult);
  17.562 +                    }
  17.563                  }
  17.564 -            };
  17.565 -            ResultInfo twrResult = new ResultInfo(VAL, syms.autoCloseableType, twrContext);
  17.566 -            if (resource.hasTag(VARDEF)) {
  17.567 -                attribStat(resource, tryEnv);
  17.568 -                twrResult.check(resource, resource.type);
  17.569 -
  17.570 -                //check that resource type cannot throw InterruptedException
  17.571 -                checkAutoCloseable(resource.pos(), localEnv, resource.type);
  17.572 -
  17.573 -                VarSymbol var = (VarSymbol)TreeInfo.symbolFor(resource);
  17.574 -                var.setData(ElementKind.RESOURCE_VARIABLE);
  17.575 -            } else {
  17.576 -                attribTree(resource, tryEnv, twrResult);
  17.577 +                // Attribute body
  17.578 +                attribStat(tree.body, tryEnv);
  17.579 +            } finally {
  17.580 +                if (isTryWithResource)
  17.581 +                    tryEnv.info.scope.leave();
  17.582              }
  17.583 +
  17.584 +            // Attribute catch clauses
  17.585 +            for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
  17.586 +                JCCatch c = l.head;
  17.587 +                Env<AttrContext> catchEnv =
  17.588 +                    localEnv.dup(c, localEnv.info.dup(localEnv.info.scope.dup()));
  17.589 +                try {
  17.590 +                    Type ctype = attribStat(c.param, catchEnv);
  17.591 +                    if (TreeInfo.isMultiCatch(c)) {
  17.592 +                        //multi-catch parameter is implicitly marked as final
  17.593 +                        c.param.sym.flags_field |= FINAL | UNION;
  17.594 +                    }
  17.595 +                    if (c.param.sym.kind == Kinds.VAR) {
  17.596 +                        c.param.sym.setData(ElementKind.EXCEPTION_PARAMETER);
  17.597 +                    }
  17.598 +                    chk.checkType(c.param.vartype.pos(),
  17.599 +                                  chk.checkClassType(c.param.vartype.pos(), ctype),
  17.600 +                                  syms.throwableType);
  17.601 +                    attribStat(c.body, catchEnv);
  17.602 +                } finally {
  17.603 +                    catchEnv.info.scope.leave();
  17.604 +                }
  17.605 +            }
  17.606 +
  17.607 +            // Attribute finalizer
  17.608 +            if (tree.finalizer != null) attribStat(tree.finalizer, localEnv);
  17.609 +            result = null;
  17.610          }
  17.611 -        // Attribute body
  17.612 -        attribStat(tree.body, tryEnv);
  17.613 -        if (isTryWithResource)
  17.614 -            tryEnv.info.scope.leave();
  17.615 -
  17.616 -        // Attribute catch clauses
  17.617 -        for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
  17.618 -            JCCatch c = l.head;
  17.619 -            Env<AttrContext> catchEnv =
  17.620 -                localEnv.dup(c, localEnv.info.dup(localEnv.info.scope.dup()));
  17.621 -            Type ctype = attribStat(c.param, catchEnv);
  17.622 -            if (TreeInfo.isMultiCatch(c)) {
  17.623 -                //multi-catch parameter is implicitly marked as final
  17.624 -                c.param.sym.flags_field |= FINAL | UNION;
  17.625 -            }
  17.626 -            if (c.param.sym.kind == Kinds.VAR) {
  17.627 -                c.param.sym.setData(ElementKind.EXCEPTION_PARAMETER);
  17.628 -            }
  17.629 -            chk.checkType(c.param.vartype.pos(),
  17.630 -                          chk.checkClassType(c.param.vartype.pos(), ctype),
  17.631 -                          syms.throwableType);
  17.632 -            attribStat(c.body, catchEnv);
  17.633 -            catchEnv.info.scope.leave();
  17.634 +        finally {
  17.635 +            localEnv.info.scope.leave();
  17.636          }
  17.637 -
  17.638 -        // Attribute finalizer
  17.639 -        if (tree.finalizer != null) attribStat(tree.finalizer, localEnv);
  17.640 -
  17.641 -        localEnv.info.scope.leave();
  17.642 -        result = null;
  17.643      }
  17.644  
  17.645      void checkAutoCloseable(DiagnosticPosition pos, Env<AttrContext> env, Type resource) {
  17.646 @@ -1222,10 +1351,10 @@
  17.647              types.asSuper(resource, syms.autoCloseableType.tsym) != null &&
  17.648              !types.isSameType(resource, syms.autoCloseableType)) { // Don't emit warning for AutoCloseable itself
  17.649              Symbol close = syms.noSymbol;
  17.650 -            boolean prevDeferDiags = log.deferDiagnostics;
  17.651 +            Filter<JCDiagnostic> prevDeferDiagsFilter = log.deferredDiagFilter;
  17.652              Queue<JCDiagnostic> prevDeferredDiags = log.deferredDiagnostics;
  17.653              try {
  17.654 -                log.deferDiagnostics = true;
  17.655 +                log.deferAll();
  17.656                  log.deferredDiagnostics = ListBuffer.lb();
  17.657                  close = rs.resolveQualifiedMethod(pos,
  17.658                          env,
  17.659 @@ -1235,7 +1364,7 @@
  17.660                          List.<Type>nil());
  17.661              }
  17.662              finally {
  17.663 -                log.deferDiagnostics = prevDeferDiags;
  17.664 +                log.deferredDiagFilter = prevDeferDiagsFilter;
  17.665                  log.deferredDiagnostics = prevDeferredDiags;
  17.666              }
  17.667              if (close.kind == MTH &&
  17.668 @@ -1248,50 +1377,71 @@
  17.669      }
  17.670  
  17.671      public void visitConditional(JCConditional tree) {
  17.672 -        attribExpr(tree.cond, env, syms.booleanType);
  17.673 -        attribExpr(tree.truepart, env);
  17.674 -        attribExpr(tree.falsepart, env);
  17.675 -        result = check(tree,
  17.676 -                       capture(condType(tree.pos(), tree.cond.type,
  17.677 -                                        tree.truepart.type, tree.falsepart.type)),
  17.678 -                       VAL, resultInfo);
  17.679 +        Type condtype = attribExpr(tree.cond, env, syms.booleanType);
  17.680 +
  17.681 +        boolean standaloneConditional = !allowPoly ||
  17.682 +                pt().tag == NONE && pt() != Type.recoveryType ||
  17.683 +                isBooleanOrNumeric(env, tree);
  17.684 +
  17.685 +        if (!standaloneConditional && resultInfo.pt.tag == VOID) {
  17.686 +            //cannot get here (i.e. it means we are returning from void method - which is already an error)
  17.687 +            result = tree.type = types.createErrorType(resultInfo.pt);
  17.688 +            return;
  17.689 +        }
  17.690 +
  17.691 +        ResultInfo condInfo = standaloneConditional ?
  17.692 +                unknownExprInfo :
  17.693 +                new ResultInfo(VAL, pt(), new Check.NestedCheckContext(resultInfo.checkContext) {
  17.694 +                    //this will use enclosing check context to check compatibility of
  17.695 +                    //subexpression against target type; if we are in a method check context,
  17.696 +                    //depending on whether boxing is allowed, we could have incompatibilities
  17.697 +                    @Override
  17.698 +                    public void report(DiagnosticPosition pos, JCDiagnostic details) {
  17.699 +                        enclosingContext.report(pos, diags.fragment("incompatible.type.in.conditional", details));
  17.700 +                    }
  17.701 +                });
  17.702 +
  17.703 +        Type truetype = attribTree(tree.truepart, env, condInfo);
  17.704 +        Type falsetype = attribTree(tree.falsepart, env, condInfo);
  17.705 +
  17.706 +        Type owntype = standaloneConditional ? condType(tree, truetype, falsetype) : pt();
  17.707 +        if (condtype.constValue() != null &&
  17.708 +                truetype.constValue() != null &&
  17.709 +                falsetype.constValue() != null) {
  17.710 +            //constant folding
  17.711 +            owntype = cfolder.coerce(condtype.isTrue() ? truetype : falsetype, owntype);
  17.712 +        }
  17.713 +        result = check(tree, owntype, VAL, resultInfo);
  17.714      }
  17.715      //where
  17.716 +        @SuppressWarnings("fallthrough")
  17.717 +        private boolean isBooleanOrNumeric(Env<AttrContext> env, JCExpression tree) {
  17.718 +            switch (tree.getTag()) {
  17.719 +                case LITERAL: return ((JCLiteral)tree).typetag < CLASS;
  17.720 +                case LAMBDA: case REFERENCE: return false;
  17.721 +                case PARENS: return isBooleanOrNumeric(env, ((JCParens)tree).expr);
  17.722 +                case CONDEXPR:
  17.723 +                    JCConditional condTree = (JCConditional)tree;
  17.724 +                    return isBooleanOrNumeric(env, condTree.truepart) &&
  17.725 +                            isBooleanOrNumeric(env, condTree.falsepart);
  17.726 +                default:
  17.727 +                    Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo).type;
  17.728 +                    speculativeType = types.unboxedTypeOrType(speculativeType);
  17.729 +                    return speculativeType.tag <= BOOLEAN;
  17.730 +            }
  17.731 +        }
  17.732 +
  17.733          /** Compute the type of a conditional expression, after
  17.734 -         *  checking that it exists. See Spec 15.25.
  17.735 -         *
  17.736 -         *  @param pos      The source position to be used for
  17.737 -         *                  error diagnostics.
  17.738 -         *  @param condtype The type of the expression's condition.
  17.739 -         *  @param thentype The type of the expression's then-part.
  17.740 -         *  @param elsetype The type of the expression's else-part.
  17.741 -         */
  17.742 -        private Type condType(DiagnosticPosition pos,
  17.743 -                              Type condtype,
  17.744 -                              Type thentype,
  17.745 -                              Type elsetype) {
  17.746 -            Type ctype = condType1(pos, condtype, thentype, elsetype);
  17.747 -
  17.748 -            // If condition and both arms are numeric constants,
  17.749 -            // evaluate at compile-time.
  17.750 -            return ((condtype.constValue() != null) &&
  17.751 -                    (thentype.constValue() != null) &&
  17.752 -                    (elsetype.constValue() != null))
  17.753 -                ? cfolder.coerce(condtype.isTrue()?thentype:elsetype, ctype)
  17.754 -                : ctype;
  17.755 -        }
  17.756 -        /** Compute the type of a conditional expression, after
  17.757 -         *  checking that it exists.  Does not take into
  17.758 +         *  checking that it exists.  See JLS 15.25. Does not take into
  17.759           *  account the special case where condition and both arms
  17.760           *  are constants.
  17.761           *
  17.762           *  @param pos      The source position to be used for error
  17.763           *                  diagnostics.
  17.764 -         *  @param condtype The type of the expression's condition.
  17.765           *  @param thentype The type of the expression's then-part.
  17.766           *  @param elsetype The type of the expression's else-part.
  17.767           */
  17.768 -        private Type condType1(DiagnosticPosition pos, Type condtype,
  17.769 +        private Type condType(DiagnosticPosition pos,
  17.770                                 Type thentype, Type elsetype) {
  17.771              // If same type, that is the result
  17.772              if (types.isSameType(thentype, elsetype))
  17.773 @@ -1399,37 +1549,38 @@
  17.774              LOOP:
  17.775              while (env1 != null) {
  17.776                  switch (env1.tree.getTag()) {
  17.777 -                case LABELLED:
  17.778 -                    JCLabeledStatement labelled = (JCLabeledStatement)env1.tree;
  17.779 -                    if (label == labelled.label) {
  17.780 -                        // If jump is a continue, check that target is a loop.
  17.781 -                        if (tag == CONTINUE) {
  17.782 -                            if (!labelled.body.hasTag(DOLOOP) &&
  17.783 -                                !labelled.body.hasTag(WHILELOOP) &&
  17.784 -                                !labelled.body.hasTag(FORLOOP) &&
  17.785 -                                !labelled.body.hasTag(FOREACHLOOP))
  17.786 -                                log.error(pos, "not.loop.label", label);
  17.787 -                            // Found labelled statement target, now go inwards
  17.788 -                            // to next non-labelled tree.
  17.789 -                            return TreeInfo.referencedStatement(labelled);
  17.790 -                        } else {
  17.791 -                            return labelled;
  17.792 +                    case LABELLED:
  17.793 +                        JCLabeledStatement labelled = (JCLabeledStatement)env1.tree;
  17.794 +                        if (label == labelled.label) {
  17.795 +                            // If jump is a continue, check that target is a loop.
  17.796 +                            if (tag == CONTINUE) {
  17.797 +                                if (!labelled.body.hasTag(DOLOOP) &&
  17.798 +                                        !labelled.body.hasTag(WHILELOOP) &&
  17.799 +                                        !labelled.body.hasTag(FORLOOP) &&
  17.800 +                                        !labelled.body.hasTag(FOREACHLOOP))
  17.801 +                                    log.error(pos, "not.loop.label", label);
  17.802 +                                // Found labelled statement target, now go inwards
  17.803 +                                // to next non-labelled tree.
  17.804 +                                return TreeInfo.referencedStatement(labelled);
  17.805 +                            } else {
  17.806 +                                return labelled;
  17.807 +                            }
  17.808                          }
  17.809 -                    }
  17.810 -                    break;
  17.811 -                case DOLOOP:
  17.812 -                case WHILELOOP:
  17.813 -                case FORLOOP:
  17.814 -                case FOREACHLOOP:
  17.815 -                    if (label == null) return env1.tree;
  17.816 -                    break;
  17.817 -                case SWITCH:
  17.818 -                    if (label == null && tag == BREAK) return env1.tree;
  17.819 -                    break;
  17.820 -                case METHODDEF:
  17.821 -                case CLASSDEF:
  17.822 -                    break LOOP;
  17.823 -                default:
  17.824 +                        break;
  17.825 +                    case DOLOOP:
  17.826 +                    case WHILELOOP:
  17.827 +                    case FORLOOP:
  17.828 +                    case FOREACHLOOP:
  17.829 +                        if (label == null) return env1.tree;
  17.830 +                        break;
  17.831 +                    case SWITCH:
  17.832 +                        if (label == null && tag == BREAK) return env1.tree;
  17.833 +                        break;
  17.834 +                    case LAMBDA:
  17.835 +                    case METHODDEF:
  17.836 +                    case CLASSDEF:
  17.837 +                        break LOOP;
  17.838 +                    default:
  17.839                  }
  17.840                  env1 = env1.next;
  17.841              }
  17.842 @@ -1445,22 +1596,19 @@
  17.843      public void visitReturn(JCReturn tree) {
  17.844          // Check that there is an enclosing method which is
  17.845          // nested within than the enclosing class.
  17.846 -        if (env.enclMethod == null ||
  17.847 -            env.enclMethod.sym.owner != env.enclClass.sym) {
  17.848 +        if (env.info.returnResult == null) {
  17.849              log.error(tree.pos(), "ret.outside.meth");
  17.850 -
  17.851          } else {
  17.852              // Attribute return expression, if it exists, and check that
  17.853              // it conforms to result type of enclosing method.
  17.854 -            Symbol m = env.enclMethod.sym;
  17.855 -            if (m.type.getReturnType().tag == VOID) {
  17.856 -                if (tree.expr != null)
  17.857 +            if (tree.expr != null) {
  17.858 +                if (env.info.returnResult.pt.tag == VOID) {
  17.859                      log.error(tree.expr.pos(),
  17.860                                "cant.ret.val.from.meth.decl.void");
  17.861 -            } else if (tree.expr == null) {
  17.862 +                }
  17.863 +                attribTree(tree.expr, env, env.info.returnResult);
  17.864 +            } else if (env.info.returnResult.pt.tag != VOID) {
  17.865                  log.error(tree.pos(), "missing.ret.val");
  17.866 -            } else {
  17.867 -                attribExpr(tree.expr, env, m.type.getReturnType());
  17.868              }
  17.869          }
  17.870          result = null;
  17.871 @@ -1562,7 +1710,7 @@
  17.872                      // current instance (JLS ???).
  17.873                      boolean selectSuperPrev = localEnv.info.selectSuper;
  17.874                      localEnv.info.selectSuper = true;
  17.875 -                    localEnv.info.varArgs = false;
  17.876 +                    localEnv.info.pendingResolutionPhase = null;
  17.877                      Symbol sym = rs.resolveConstructor(
  17.878                          tree.meth.pos(), localEnv, site, argtypes, typeargtypes);
  17.879                      localEnv.info.selectSuper = selectSuperPrev;
  17.880 @@ -1573,8 +1721,7 @@
  17.881                      // ...and check that it is legal in the current context.
  17.882                      // (this will also set the tree's type)
  17.883                      Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);
  17.884 -                    checkId(tree.meth, site, sym, localEnv, new ResultInfo(MTH, mpt),
  17.885 -                            tree.varargsElement != null);
  17.886 +                    checkId(tree.meth, site, sym, localEnv, new ResultInfo(MTH, mpt));
  17.887                  }
  17.888                  // Otherwise, `site' is an error type and we do nothing
  17.889              }
  17.890 @@ -1589,35 +1736,18 @@
  17.891              // whose formal argument types is exactly the list of actual
  17.892              // arguments (this will also set the method symbol).
  17.893              Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);
  17.894 -            localEnv.info.varArgs = false;
  17.895 -            Type mtype = attribExpr(tree.meth, localEnv, mpt);
  17.896 +            localEnv.info.pendingResolutionPhase = null;
  17.897 +            Type mtype = attribTree(tree.meth, localEnv, new ResultInfo(VAL, mpt, resultInfo.checkContext));
  17.898  
  17.899              // Compute the result type.
  17.900              Type restype = mtype.getReturnType();
  17.901              if (restype.tag == WILDCARD)
  17.902                  throw new AssertionError(mtype);
  17.903  
  17.904 -            // as a special case, array.clone() has a result that is
  17.905 -            // the same as static type of the array being cloned
  17.906 -            if (tree.meth.hasTag(SELECT) &&
  17.907 -                allowCovariantReturns &&
  17.908 -                methName == names.clone &&
  17.909 -                types.isArray(((JCFieldAccess) tree.meth).selected.type))
  17.910 -                restype = ((JCFieldAccess) tree.meth).selected.type;
  17.911 -
  17.912 -            // as a special case, x.getClass() has type Class<? extends |X|>
  17.913 -            if (allowGenerics &&
  17.914 -                methName == names.getClass && tree.args.isEmpty()) {
  17.915 -                Type qualifier = (tree.meth.hasTag(SELECT))
  17.916 +            Type qualifier = (tree.meth.hasTag(SELECT))
  17.917                      ? ((JCFieldAccess) tree.meth).selected.type
  17.918                      : env.enclClass.sym.type;
  17.919 -                restype = new
  17.920 -                    ClassType(restype.getEnclosingType(),
  17.921 -                              List.<Type>of(new WildcardType(types.erasure(qualifier),
  17.922 -                                                               BoundKind.EXTENDS,
  17.923 -                                                               syms.boundClass)),
  17.924 -                              restype.tsym);
  17.925 -            }
  17.926 +            restype = adjustMethodReturnType(qualifier, methName, argtypes, restype);
  17.927  
  17.928              chk.checkRefTypes(tree.typeargs, typeargtypes);
  17.929  
  17.930 @@ -1625,12 +1755,33 @@
  17.931              // current context.  Also, capture the return type
  17.932              result = check(tree, capture(restype), VAL, resultInfo);
  17.933  
  17.934 -            if (localEnv.info.varArgs)
  17.935 +            if (localEnv.info.lastResolveVarargs())
  17.936                  Assert.check(result.isErroneous() || tree.varargsElement != null);
  17.937          }
  17.938          chk.validate(tree.typeargs, localEnv);
  17.939      }
  17.940      //where
  17.941 +        Type adjustMethodReturnType(Type qualifierType, Name methodName, List<Type> argtypes, Type restype) {
  17.942 +            if (allowCovariantReturns &&
  17.943 +                    methodName == names.clone &&
  17.944 +                types.isArray(qualifierType)) {
  17.945 +                // as a special case, array.clone() has a result that is
  17.946 +                // the same as static type of the array being cloned
  17.947 +                return qualifierType;
  17.948 +            } else if (allowGenerics &&
  17.949 +                    methodName == names.getClass &&
  17.950 +                    argtypes.isEmpty()) {
  17.951 +                // as a special case, x.getClass() has type Class<? extends |X|>
  17.952 +                return new ClassType(restype.getEnclosingType(),
  17.953 +                              List.<Type>of(new WildcardType(types.erasure(qualifierType),
  17.954 +                                                               BoundKind.EXTENDS,
  17.955 +                                                               syms.boundClass)),
  17.956 +                              restype.tsym);
  17.957 +            } else {
  17.958 +                return restype;
  17.959 +            }
  17.960 +        }
  17.961 +
  17.962          /** Check that given application node appears as first statement
  17.963           *  in a constructor call.
  17.964           *  @param tree   The application node
  17.965 @@ -1652,11 +1803,11 @@
  17.966          /** Obtain a method type with given argument types.
  17.967           */
  17.968          Type newMethodTemplate(Type restype, List<Type> argtypes, List<Type> typeargtypes) {
  17.969 -            MethodType mt = new MethodType(argtypes, restype, null, syms.methodClass);
  17.970 +            MethodType mt = new MethodType(argtypes, restype, List.<Type>nil(), syms.methodClass);
  17.971              return (typeargtypes == null) ? mt : (Type)new ForAll(typeargtypes, mt);
  17.972          }
  17.973  
  17.974 -    public void visitNewClass(JCNewClass tree) {
  17.975 +    public void visitNewClass(final JCNewClass tree) {
  17.976          Type owntype = types.createErrorType(tree.type);
  17.977  
  17.978          // The local environment of a class creation is
  17.979 @@ -1729,42 +1880,6 @@
  17.980          List<Type> argtypes = attribArgs(tree.args, localEnv);
  17.981          List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
  17.982  
  17.983 -        if (TreeInfo.isDiamond(tree) && !clazztype.isErroneous()) {
  17.984 -            clazztype = attribDiamond(localEnv, tree, clazztype, argtypes, typeargtypes);
  17.985 -            clazz.type = clazztype;
  17.986 -        } else if (allowDiamondFinder &&
  17.987 -                tree.def == null &&
  17.988 -                !clazztype.isErroneous() &&
  17.989 -                clazztype.getTypeArguments().nonEmpty() &&
  17.990 -                findDiamonds) {
  17.991 -            boolean prevDeferDiags = log.deferDiagnostics;
  17.992 -            Queue<JCDiagnostic> prevDeferredDiags = log.deferredDiagnostics;
  17.993 -            Type inferred = null;
  17.994 -            try {
  17.995 -                //disable diamond-related diagnostics
  17.996 -                log.deferDiagnostics = true;
  17.997 -                log.deferredDiagnostics = ListBuffer.lb();
  17.998 -                inferred = attribDiamond(localEnv,
  17.999 -                        tree,
 17.1000 -                        clazztype,
 17.1001 -                        argtypes,
 17.1002 -                        typeargtypes);
 17.1003 -            }
 17.1004 -            finally {
 17.1005 -                log.deferDiagnostics = prevDeferDiags;
 17.1006 -                log.deferredDiagnostics = prevDeferredDiags;
 17.1007 -            }
 17.1008 -            if (inferred != null &&
 17.1009 -                    !inferred.isErroneous() &&
 17.1010 -                    inferred.tag == CLASS &&
 17.1011 -                    types.isAssignable(inferred, pt().tag == NONE ? clazztype : pt(), Warner.noWarnings)) {
 17.1012 -                String key = types.isSameType(clazztype, inferred) ?
 17.1013 -                    "diamond.redundant.args" :
 17.1014 -                    "diamond.redundant.args.1";
 17.1015 -                log.warning(tree.clazz.pos(), key, clazztype, inferred);
 17.1016 -            }
 17.1017 -        }
 17.1018 -
 17.1019          // If we have made no mistakes in the class type...
 17.1020          if (clazztype.tag == CLASS) {
 17.1021              // Enums may not be instantiated except implicitly
 17.1022 @@ -1791,6 +1906,45 @@
 17.1023                  // Error recovery: pretend no arguments were supplied.
 17.1024                  argtypes = List.nil();
 17.1025                  typeargtypes = List.nil();
 17.1026 +            } else if (TreeInfo.isDiamond(tree)) {
 17.1027 +                ClassType site = new ClassType(clazztype.getEnclosingType(),
 17.1028 +                            clazztype.tsym.type.getTypeArguments(),
 17.1029 +                            clazztype.tsym);
 17.1030 +
 17.1031 +                Env<AttrContext> diamondEnv = localEnv.dup(tree);
 17.1032 +                diamondEnv.info.selectSuper = cdef != null;
 17.1033 +                diamondEnv.info.pendingResolutionPhase = null;
 17.1034 +
 17.1035 +                //if the type of the instance creation expression is a class type
 17.1036 +                //apply method resolution inference (JLS 15.12.2.7). The return type
 17.1037 +                //of the resolved constructor will be a partially instantiated type
 17.1038 +                Symbol constructor = rs.resolveDiamond(tree.pos(),
 17.1039 +                            diamondEnv,
 17.1040 +                            site,
 17.1041 +                            argtypes,
 17.1042 +                            typeargtypes);
 17.1043 +                tree.constructor = constructor.baseSymbol();
 17.1044 +
 17.1045 +                final TypeSymbol csym = clazztype.tsym;
 17.1046 +                ResultInfo diamondResult = new ResultInfo(MTH, newMethodTemplate(resultInfo.pt, argtypes, typeargtypes), new Check.NestedCheckContext(resultInfo.checkContext) {
 17.1047 +                    @Override
 17.1048 +                    public void report(DiagnosticPosition _unused, JCDiagnostic details) {
 17.1049 +                        enclosingContext.report(tree.clazz,
 17.1050 +                                diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", csym), details));
 17.1051 +                    }
 17.1052 +                });
 17.1053 +                Type constructorType = tree.constructorType = types.createErrorType(clazztype);
 17.1054 +                constructorType = checkId(tree, site,
 17.1055 +                        constructor,
 17.1056 +                        diamondEnv,
 17.1057 +                        diamondResult);
 17.1058 +
 17.1059 +                tree.clazz.type = types.createErrorType(clazztype);
 17.1060 +                if (!constructorType.isErroneous()) {
 17.1061 +                    tree.clazz.type = clazztype = constructorType.getReturnType();
 17.1062 +                    tree.constructorType = types.createMethodTypeWithReturn(constructorType, syms.voidType);
 17.1063 +                }
 17.1064 +                clazztype = chk.checkClassType(tree.clazz, tree.clazz.type, true);
 17.1065              }
 17.1066  
 17.1067              // Resolve the called constructor under the assumption
 17.1068 @@ -1802,20 +1956,19 @@
 17.1069                  //order to avoid downstream failures
 17.1070                  Env<AttrContext> rsEnv = localEnv.dup(tree);
 17.1071                  rsEnv.info.selectSuper = cdef != null;
 17.1072 -                rsEnv.info.varArgs = false;
 17.1073 +                rsEnv.info.pendingResolutionPhase = null;
 17.1074                  tree.constructor = rs.resolveConstructor(
 17.1075                      tree.pos(), rsEnv, clazztype, argtypes, typeargtypes);
 17.1076 -                tree.constructorType = tree.constructor.type.isErroneous() ?
 17.1077 -                    syms.errType :
 17.1078 -                    checkConstructor(clazztype,
 17.1079 -                        tree.constructor,
 17.1080 -                        rsEnv,
 17.1081 -                        tree.args,
 17.1082 -                        argtypes,
 17.1083 -                        typeargtypes,
 17.1084 -                        rsEnv.info.varArgs);
 17.1085 -                if (rsEnv.info.varArgs)
 17.1086 -                    Assert.check(tree.constructorType.isErroneous() || tree.varargsElement != null);
 17.1087 +                if (cdef == null) { //do not check twice!
 17.1088 +                    tree.constructorType = checkId(tree,
 17.1089 +                            clazztype,
 17.1090 +                            tree.constructor,
 17.1091 +                            rsEnv,
 17.1092 +                            new ResultInfo(MTH, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
 17.1093 +                    if (rsEnv.info.lastResolveVarargs())
 17.1094 +                        Assert.check(tree.constructorType.isErroneous() || tree.varargsElement != null);
 17.1095 +                }
 17.1096 +                findDiamondIfNeeded(localEnv, tree, clazztype);
 17.1097              }
 17.1098  
 17.1099              if (cdef != null) {
 17.1100 @@ -1861,6 +2014,8 @@
 17.1101  
 17.1102                  attribStat(cdef, localEnv);
 17.1103  
 17.1104 +                checkLambdaCandidate(tree, cdef.sym, clazztype);
 17.1105 +
 17.1106                  // If an outer instance is given,
 17.1107                  // prefix it to the constructor arguments
 17.1108                  // and delete it from the new expression
 17.1109 @@ -1872,24 +2027,15 @@
 17.1110  
 17.1111                  // Reassign clazztype and recompute constructor.
 17.1112                  clazztype = cdef.sym.type;
 17.1113 -                boolean useVarargs = tree.varargsElement != null;
 17.1114 -                Symbol sym = rs.resolveConstructor(
 17.1115 -                    tree.pos(), localEnv, clazztype, argtypes,
 17.1116 -                    typeargtypes, true, useVarargs);
 17.1117 -                Assert.check(sym.kind < AMBIGUOUS || tree.constructor.type.isErroneous());
 17.1118 +                Symbol sym = tree.constructor = rs.resolveConstructor(
 17.1119 +                    tree.pos(), localEnv, clazztype, argtypes, typeargtypes);
 17.1120 +                Assert.check(sym.kind < AMBIGUOUS);
 17.1121                  tree.constructor = sym;
 17.1122 -                if (tree.constructor.kind > ERRONEOUS) {
 17.1123 -                    tree.constructorType =  syms.errType;
 17.1124 -                }
 17.1125 -                else {
 17.1126 -                    tree.constructorType = checkConstructor(clazztype,
 17.1127 -                            tree.constructor,
 17.1128 -                            localEnv,
 17.1129 -                            tree.args,
 17.1130 -                            argtypes,
 17.1131 -                            typeargtypes,
 17.1132 -                            useVarargs);
 17.1133 -                }
 17.1134 +                tree.constructorType = checkId(tree,
 17.1135 +                    clazztype,
 17.1136 +                    tree.constructor,
 17.1137 +                    localEnv,
 17.1138 +                    new ResultInfo(VAL, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
 17.1139              }
 17.1140  
 17.1141              if (tree.constructor != null && tree.constructor.kind == MTH)
 17.1142 @@ -1898,57 +2044,58 @@
 17.1143          result = check(tree, owntype, VAL, resultInfo);
 17.1144          chk.validate(tree.typeargs, localEnv);
 17.1145      }
 17.1146 -
 17.1147 -    Type attribDiamond(Env<AttrContext> env,
 17.1148 -                        final JCNewClass tree,
 17.1149 -                        final Type clazztype,
 17.1150 -                        List<Type> argtypes,
 17.1151 -                        List<Type> typeargtypes) {
 17.1152 -        if (clazztype.isErroneous() ||
 17.1153 -                clazztype.isInterface()) {
 17.1154 -            //if the type of the instance creation expression is erroneous,
 17.1155 -            //or if it's an interface, or if something prevented us to form a valid
 17.1156 -            //mapping, return the (possibly erroneous) type unchanged
 17.1157 -            return clazztype;
 17.1158 +    //where
 17.1159 +        void findDiamondIfNeeded(Env<AttrContext> env, JCNewClass tree, Type clazztype) {
 17.1160 +            if (tree.def == null &&
 17.1161 +                    !clazztype.isErroneous() &&
 17.1162 +                    clazztype.getTypeArguments().nonEmpty() &&
 17.1163 +                    findDiamonds) {
 17.1164 +                JCTypeApply ta = (JCTypeApply)tree.clazz;
 17.1165 +                List<JCExpression> prevTypeargs = ta.arguments;
 17.1166 +                try {
 17.1167 +                    //create a 'fake' diamond AST node by removing type-argument trees
 17.1168 +                    ta.arguments = List.nil();
 17.1169 +                    ResultInfo findDiamondResult = new ResultInfo(VAL,
 17.1170 +                            resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
 17.1171 +                    Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
 17.1172 +                    if (!inferred.isErroneous() &&
 17.1173 +                        types.isAssignable(inferred, pt().tag == NONE ? syms.objectType : pt(), Warner.noWarnings)) {
 17.1174 +                        String key = types.isSameType(clazztype, inferred) ?
 17.1175 +                            "diamond.redundant.args" :
 17.1176 +                            "diamond.redundant.args.1";
 17.1177 +                        log.warning(tree.clazz.pos(), key, clazztype, inferred);
 17.1178 +                    }
 17.1179 +                } finally {
 17.1180 +                    ta.arguments = prevTypeargs;
 17.1181 +                }
 17.1182 +            }
 17.1183          }
 17.1184  
 17.1185 -        //dup attribution environment and augment the set of inference variables
 17.1186 -        Env<AttrContext> localEnv = env.dup(tree);
 17.1187 -
 17.1188 -        ClassType site = new ClassType(clazztype.getEnclosingType(),
 17.1189 -                    clazztype.tsym.type.getTypeArguments(),
 17.1190 -                    clazztype.tsym);
 17.1191 -
 17.1192 -        //if the type of the instance creation expression is a class type
 17.1193 -        //apply method resolution inference (JLS 15.12.2.7). The return type
 17.1194 -        //of the resolved constructor will be a partially instantiated type
 17.1195 -        Symbol constructor = rs.resolveDiamond(tree.pos(),
 17.1196 -                    localEnv,
 17.1197 -                    site,
 17.1198 -                    argtypes,
 17.1199 -                    typeargtypes);
 17.1200 -
 17.1201 -        Type owntype = types.createErrorType(clazztype);
 17.1202 -        if (constructor.kind == MTH) {
 17.1203 -            ResultInfo diamondResult = new ResultInfo(VAL, resultInfo.pt, new Check.NestedCheckContext(resultInfo.checkContext) {
 17.1204 -                @Override
 17.1205 -                public void report(DiagnosticPosition pos, JCDiagnostic details) {
 17.1206 -                    enclosingContext.report(tree.clazz.pos(),
 17.1207 -                            diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", clazztype.tsym), details));
 17.1208 +            private void checkLambdaCandidate(JCNewClass tree, ClassSymbol csym, Type clazztype) {
 17.1209 +                if (allowLambda &&
 17.1210 +                        identifyLambdaCandidate &&
 17.1211 +                        clazztype.tag == CLASS &&
 17.1212 +                        pt().tag != NONE &&
 17.1213 +                        types.isFunctionalInterface(clazztype.tsym)) {
 17.1214 +                    Symbol descriptor = types.findDescriptorSymbol(clazztype.tsym);
 17.1215 +                    int count = 0;
 17.1216 +                    boolean found = false;
 17.1217 +                    for (Symbol sym : csym.members().getElements()) {
 17.1218 +                        if ((sym.flags() & SYNTHETIC) != 0 ||
 17.1219 +                                sym.isConstructor()) continue;
 17.1220 +                        count++;
 17.1221 +                        if (sym.kind != MTH ||
 17.1222 +                                !sym.name.equals(descriptor.name)) continue;
 17.1223 +                        Type mtype = types.memberType(clazztype, sym);
 17.1224 +                        if (types.overrideEquivalent(mtype, types.memberType(clazztype, descriptor))) {
 17.1225 +                            found = true;
 17.1226 +                        }
 17.1227 +                    }
 17.1228 +                    if (found && count == 1) {
 17.1229 +                        log.note(tree.def, "potential.lambda.found");
 17.1230 +                    }
 17.1231                  }
 17.1232 -            });
 17.1233 -            owntype = checkMethod(site,
 17.1234 -                    constructor,
 17.1235 -                    diamondResult,
 17.1236 -                    localEnv,
 17.1237 -                    tree.args,
 17.1238 -                    argtypes,
 17.1239 -                    typeargtypes,
 17.1240 -                    localEnv.info.varArgs).getReturnType();
 17.1241 -        }
 17.1242 -
 17.1243 -        return chk.checkClassType(tree.clazz.pos(), owntype, true);
 17.1244 -    }
 17.1245 +            }
 17.1246  
 17.1247      /** Make an attributed null check tree.
 17.1248       */
 17.1249 @@ -1966,13 +2113,14 @@
 17.1250  
 17.1251      public void visitNewArray(JCNewArray tree) {
 17.1252          Type owntype = types.createErrorType(tree.type);
 17.1253 +        Env<AttrContext> localEnv = env.dup(tree);
 17.1254          Type elemtype;
 17.1255          if (tree.elemtype != null) {
 17.1256 -            elemtype = attribType(tree.elemtype, env);
 17.1257 -            chk.validate(tree.elemtype, env);
 17.1258 +            elemtype = attribType(tree.elemtype, localEnv);
 17.1259 +            chk.validate(tree.elemtype, localEnv);
 17.1260              owntype = elemtype;
 17.1261              for (List<JCExpression> l = tree.dims; l.nonEmpty(); l = l.tail) {
 17.1262 -                attribExpr(l.head, env, syms.intType);
 17.1263 +                attribExpr(l.head, localEnv, syms.intType);
 17.1264                  owntype = new ArrayType(owntype, syms.arrayClass);
 17.1265              }
 17.1266          } else {
 17.1267 @@ -1989,7 +2137,7 @@
 17.1268              }
 17.1269          }
 17.1270          if (tree.elems != null) {
 17.1271 -            attribExprs(tree.elems, env, elemtype);
 17.1272 +            attribExprs(tree.elems, localEnv, elemtype);
 17.1273              owntype = new ArrayType(elemtype, syms.arrayClass);
 17.1274          }
 17.1275          if (!types.isReifiable(elemtype))
 17.1276 @@ -1997,14 +2145,394 @@
 17.1277          result = check(tree, owntype, VAL, resultInfo);
 17.1278      }
 17.1279  
 17.1280 +    /*
 17.1281 +     * A lambda expression can only be attributed when a target-type is available.
 17.1282 +     * In addition, if the target-type is that of a functional interface whose
 17.1283 +     * descriptor contains inference variables in argument position the lambda expression
 17.1284 +     * is 'stuck' (see DeferredAttr).
 17.1285 +     */
 17.1286      @Override
 17.1287 -    public void visitLambda(JCLambda that) {
 17.1288 -        throw new UnsupportedOperationException("Lambda expression not supported yet");
 17.1289 +    public void visitLambda(final JCLambda that) {
 17.1290 +        if (pt().isErroneous() || (pt().tag == NONE && pt() != Type.recoveryType)) {
 17.1291 +            if (pt().tag == NONE) {
 17.1292 +                //lambda only allowed in assignment or method invocation/cast context
 17.1293 +                log.error(that.pos(), "unexpected.lambda");
 17.1294 +            }
 17.1295 +            result = that.type = types.createErrorType(pt());
 17.1296 +            return;
 17.1297 +        }
 17.1298 +        //create an environment for attribution of the lambda expression
 17.1299 +        final Env<AttrContext> localEnv = lambdaEnv(that, env);
 17.1300 +        boolean needsRecovery = resultInfo.checkContext.deferredAttrContext() == deferredAttr.emptyDeferredAttrContext ||
 17.1301 +                resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK;
 17.1302 +        try {
 17.1303 +            List<Type> explicitParamTypes = null;
 17.1304 +            if (TreeInfo.isExplicitLambda(that)) {
 17.1305 +                //attribute lambda parameters
 17.1306 +                attribStats(that.params, localEnv);
 17.1307 +                explicitParamTypes = TreeInfo.types(that.params);
 17.1308 +            }
 17.1309 +
 17.1310 +            Type target = infer.instantiateFunctionalInterface(that, pt(), explicitParamTypes, resultInfo.checkContext);
 17.1311 +            Type lambdaType = (target == Type.recoveryType) ?
 17.1312 +                    fallbackDescriptorType(that) :
 17.1313 +                    types.findDescriptorType(target);
 17.1314 +
 17.1315 +            if (!TreeInfo.isExplicitLambda(that)) {
 17.1316 +                //add param type info in the AST
 17.1317 +                List<Type> actuals = lambdaType.getParameterTypes();
 17.1318 +                List<JCVariableDecl> params = that.params;
 17.1319 +
 17.1320 +                boolean arityMismatch = false;
 17.1321 +
 17.1322 +                while (params.nonEmpty()) {
 17.1323 +                    if (actuals.isEmpty()) {
 17.1324 +                        //not enough actuals to perform lambda parameter inference
 17.1325 +                        arityMismatch = true;
 17.1326 +                    }
 17.1327 +                    //reset previously set info
 17.1328 +                    Type argType = arityMismatch ?
 17.1329 +                            syms.errType :
 17.1330 +                            actuals.head;
 17.1331 +                    params.head.vartype = make.Type(argType);
 17.1332 +                    params.head.sym = null;
 17.1333 +                    actuals = actuals.isEmpty() ?
 17.1334 +                            actuals :
 17.1335 +                            actuals.tail;
 17.1336 +                    params = params.tail;
 17.1337 +                }
 17.1338 +
 17.1339 +                //attribute lambda parameters
 17.1340 +                attribStats(that.params, localEnv);
 17.1341 +
 17.1342 +                if (arityMismatch) {
 17.1343 +                    resultInfo.checkContext.report(that, diags.fragment("incompatible.arg.types.in.lambda"));
 17.1344 +                        result = that.type = types.createErrorType(target);
 17.1345 +                        return;
 17.1346 +                }
 17.1347 +            }
 17.1348 +
 17.1349 +            //from this point on, no recovery is needed; if we are in assignment context
 17.1350 +            //we will be able to attribute the whole lambda body, regardless of errors;
 17.1351 +            //if we are in a 'check' method context, and the lambda is not compatible
 17.1352 +            //with the target-type, it will be recovered anyway in Attr.checkId
 17.1353 +            needsRecovery = false;
 17.1354 +
 17.1355 +            ResultInfo bodyResultInfo = lambdaType.getReturnType() == Type.recoveryType ?
 17.1356 +                recoveryInfo :
 17.1357 +                new ResultInfo(VAL, lambdaType.getReturnType(), new LambdaReturnContext(resultInfo.checkContext));
 17.1358 +            localEnv.info.returnResult = bodyResultInfo;
 17.1359 +
 17.1360 +            if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
 17.1361 +                attribTree(that.getBody(), localEnv, bodyResultInfo);
 17.1362 +            } else {
 17.1363 +                JCBlock body = (JCBlock)that.body;
 17.1364 +                attribStats(body.stats, localEnv);
 17.1365 +            }
 17.1366 +
 17.1367 +            result = check(that, target, VAL, resultInfo);
 17.1368 +
 17.1369 +            boolean isSpeculativeRound =
 17.1370 +                    resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 17.1371 +
 17.1372 +            postAttr(that);
 17.1373 +            flow.analyzeLambda(env, that, make, isSpeculativeRound);
 17.1374 +
 17.1375 +            checkLambdaCompatible(that, lambdaType, resultInfo.checkContext, isSpeculativeRound);
 17.1376 +
 17.1377 +            if (!isSpeculativeRound) {
 17.1378 +                checkAccessibleFunctionalDescriptor(that, localEnv, resultInfo.checkContext.inferenceContext(), lambdaType);
 17.1379 +            }
 17.1380 +            result = check(that, target, VAL, resultInfo);
 17.1381 +        } catch (Types.FunctionDescriptorLookupError ex) {
 17.1382 +            JCDiagnostic cause = ex.getDiagnostic();
 17.1383 +            resultInfo.checkContext.report(that, cause);
 17.1384 +            result = that.type = types.createErrorType(pt());
 17.1385 +            return;
 17.1386 +        } finally {
 17.1387 +            localEnv.info.scope.leave();
 17.1388 +            if (needsRecovery) {
 17.1389 +                attribTree(that, env, recoveryInfo);
 17.1390 +            }
 17.1391 +        }
 17.1392      }
 17.1393 +    //where
 17.1394 +        private Type fallbackDescriptorType(JCExpression tree) {
 17.1395 +            switch (tree.getTag()) {
 17.1396 +                case LAMBDA:
 17.1397 +                    JCLambda lambda = (JCLambda)tree;
 17.1398 +                    List<Type> argtypes = List.nil();
 17.1399 +                    for (JCVariableDecl param : lambda.params) {
 17.1400 +                        argtypes = param.vartype != null ?
 17.1401 +                                argtypes.append(param.vartype.type) :
 17.1402 +                                argtypes.append(syms.errType);
 17.1403 +                    }
 17.1404 +                    return new MethodType(argtypes, Type.recoveryType, List.<Type>nil(), syms.methodClass);
 17.1405 +                case REFERENCE:
 17.1406 +                    return new MethodType(List.<Type>nil(), Type.recoveryType, List.<Type>nil(), syms.methodClass);
 17.1407 +                default:
 17.1408 +                    Assert.error("Cannot get here!");
 17.1409 +            }
 17.1410 +            return null;
 17.1411 +        }
 17.1412 +
 17.1413 +        private void checkAccessibleFunctionalDescriptor(final DiagnosticPosition pos,
 17.1414 +                final Env<AttrContext> env, final InferenceContext inferenceContext, final Type desc) {
 17.1415 +            if (inferenceContext.free(desc)) {
 17.1416 +                inferenceContext.addFreeTypeListener(List.of(desc), new FreeTypeListener() {
 17.1417 +                    @Override
 17.1418 +                    public void typesInferred(InferenceContext inferenceContext) {
 17.1419 +                        checkAccessibleFunctionalDescriptor(pos, env, inferenceContext, inferenceContext.asInstType(desc, types));
 17.1420 +                    }
 17.1421 +                });
 17.1422 +            } else {
 17.1423 +                chk.checkAccessibleFunctionalDescriptor(pos, env, desc);
 17.1424 +            }
 17.1425 +        }
 17.1426 +
 17.1427 +        /**
 17.1428 +         * Lambda/method reference have a special check context that ensures
 17.1429 +         * that i.e. a lambda return type is compatible with the expected
 17.1430 +         * type according to both the inherited context and the assignment
 17.1431 +         * context.
 17.1432 +         */
 17.1433 +        class LambdaReturnContext extends Check.NestedCheckContext {
 17.1434 +            public LambdaReturnContext(CheckContext enclosingContext) {
 17.1435 +                super(enclosingContext);
 17.1436 +            }
 17.1437 +
 17.1438 +            @Override
 17.1439 +            public boolean compatible(Type found, Type req, Warner warn) {
 17.1440 +                //return type must be compatible in both current context and assignment context
 17.1441 +                return types.isAssignable(found, inferenceContext().asFree(req, types), warn) &&
 17.1442 +                        super.compatible(found, req, warn);
 17.1443 +            }
 17.1444 +            @Override
 17.1445 +            public void report(DiagnosticPosition pos, JCDiagnostic details) {
 17.1446 +                enclosingContext.report(pos, diags.fragment("incompatible.ret.type.in.lambda", details));
 17.1447 +            }
 17.1448 +        }
 17.1449 +
 17.1450 +        /**
 17.1451 +        * Lambda compatibility. Check that given return types, thrown types, parameter types
 17.1452 +        * are compatible with the expected functional interface descriptor. This means that:
 17.1453 +        * (i) parameter types must be identical to those of the target descriptor; (ii) return
 17.1454 +        * types must be compatible with the return type of the expected descriptor;
 17.1455 +        * (iii) thrown types must be 'included' in the thrown types list of the expected
 17.1456 +        * descriptor.
 17.1457 +        */
 17.1458 +        private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext, boolean speculativeAttr) {
 17.1459 +            Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType(), types);
 17.1460 +
 17.1461 +            //return values have already been checked - but if lambda has no return
 17.1462 +            //values, we must ensure that void/value compatibility is correct;
 17.1463 +            //this amounts at checking that, if a lambda body can complete normally,
 17.1464 +            //the descriptor's return type must be void
 17.1465 +            if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
 17.1466 +                    returnType.tag != VOID && returnType != Type.recoveryType) {
 17.1467 +                checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
 17.1468 +                        diags.fragment("missing.ret.val", returnType)));
 17.1469 +            }
 17.1470 +
 17.1471 +            List<Type> argTypes = checkContext.inferenceContext().asFree(descriptor.getParameterTypes(), types);
 17.1472 +            if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
 17.1473 +                checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
 17.1474 +            }
 17.1475 +
 17.1476 +            if (!speculativeAttr) {
 17.1477 +                List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes(), types);
 17.1478 +                if (chk.unhandled(tree.inferredThrownTypes == null ? List.<Type>nil() : tree.inferredThrownTypes, thrownTypes).nonEmpty()) {
 17.1479 +                    log.error(tree, "incompatible.thrown.types.in.lambda", tree.inferredThrownTypes);
 17.1480 +                }
 17.1481 +            }
 17.1482 +        }
 17.1483 +
 17.1484 +        private Env<AttrContext> lambdaEnv(JCLambda that, Env<AttrContext> env) {
 17.1485 +            Env<AttrContext> lambdaEnv;
 17.1486 +            Symbol owner = env.info.scope.owner;
 17.1487 +            if (owner.kind == VAR && owner.owner.kind == TYP) {
 17.1488 +                //field initializer
 17.1489 +                lambdaEnv = env.dup(that, env.info.dup(env.info.scope.dupUnshared()));
 17.1490 +                lambdaEnv.info.scope.owner =
 17.1491 +                    new MethodSymbol(0, names.empty, null,
 17.1492 +                                     env.info.scope.owner);
 17.1493 +            } else {
 17.1494 +                lambdaEnv = env.dup(that, env.info.dup(env.info.scope.dup()));
 17.1495 +            }
 17.1496 +            return lambdaEnv;
 17.1497 +        }
 17.1498  
 17.1499      @Override
 17.1500 -    public void visitReference(JCMemberReference that) {
 17.1501 -        throw new UnsupportedOperationException("Member references not supported yet");
 17.1502 +    public void visitReference(final JCMemberReference that) {
 17.1503 +        if (pt().isErroneous() || (pt().tag == NONE && pt() != Type.recoveryType)) {
 17.1504 +            if (pt().tag == NONE) {
 17.1505 +                //method reference only allowed in assignment or method invocation/cast context
 17.1506 +                log.error(that.pos(), "unexpected.mref");
 17.1507 +            }
 17.1508 +            result = that.type = types.createErrorType(pt());
 17.1509 +            return;
 17.1510 +        }
 17.1511 +        final Env<AttrContext> localEnv = env.dup(that);
 17.1512 +        try {
 17.1513 +            //attribute member reference qualifier - if this is a constructor
 17.1514 +            //reference, the expected kind must be a type
 17.1515 +            Type exprType = attribTree(that.expr,
 17.1516 +                    env, new ResultInfo(that.getMode() == ReferenceMode.INVOKE ? VAL | TYP : TYP, Type.noType));
 17.1517 +
 17.1518 +            if (that.getMode() == JCMemberReference.ReferenceMode.NEW) {
 17.1519 +                exprType = chk.checkConstructorRefType(that.expr, exprType);
 17.1520 +            }
 17.1521 +
 17.1522 +            if (exprType.isErroneous()) {
 17.1523 +                //if the qualifier expression contains problems,
 17.1524 +                //give up atttribution of method reference
 17.1525 +                result = that.type = exprType;
 17.1526 +                return;
 17.1527 +            }
 17.1528 +
 17.1529 +            if (TreeInfo.isStaticSelector(that.expr, names) &&
 17.1530 +                    (that.getMode() != ReferenceMode.NEW || !that.expr.type.isRaw())) {
 17.1531 +                //if the qualifier is a type, validate it
 17.1532 +                chk.validate(that.expr, env);
 17.1533 +            }
 17.1534 +
 17.1535 +            //attrib type-arguments
 17.1536 +            List<Type> typeargtypes = null;
 17.1537 +            if (that.typeargs != null) {
 17.1538 +                typeargtypes = attribTypes(that.typeargs, localEnv);
 17.1539 +            }
 17.1540 +
 17.1541 +            Type target = infer.instantiateFunctionalInterface(that, pt(), null, resultInfo.checkContext);
 17.1542 +            Type desc = (target == Type.recoveryType) ?
 17.1543 +                    fallbackDescriptorType(that) :
 17.1544 +                    types.findDescriptorType(target);
 17.1545 +
 17.1546 +            List<Type> argtypes = desc.getParameterTypes();
 17.1547 +
 17.1548 +            boolean allowBoxing =
 17.1549 +                    resultInfo.checkContext.deferredAttrContext() == deferredAttr.emptyDeferredAttrContext ||
 17.1550 +                    resultInfo.checkContext.deferredAttrContext().phase.isBoxingRequired();
 17.1551 +            Pair<Symbol, Resolve.ReferenceLookupHelper> refResult = rs.resolveMemberReference(that.pos(), localEnv, that,
 17.1552 +                    that.expr.type, that.name, argtypes, typeargtypes, allowBoxing);
 17.1553 +
 17.1554 +            Symbol refSym = refResult.fst;
 17.1555 +            Resolve.ReferenceLookupHelper lookupHelper = refResult.snd;
 17.1556 +
 17.1557 +            if (refSym.kind != MTH) {
 17.1558 +                boolean targetError;
 17.1559 +                switch (refSym.kind) {
 17.1560 +                    case ABSENT_MTH:
 17.1561 +                        targetError = false;
 17.1562 +                        break;
 17.1563 +                    case WRONG_MTH:
 17.1564 +                    case WRONG_MTHS:
 17.1565 +                    case AMBIGUOUS:
 17.1566 +                    case HIDDEN:
 17.1567 +                    case STATICERR:
 17.1568 +                    case MISSING_ENCL:
 17.1569 +                        targetError = true;
 17.1570 +                        break;
 17.1571 +                    default:
 17.1572 +                        Assert.error("unexpected result kind " + refSym.kind);
 17.1573 +                        targetError = false;
 17.1574 +                }
 17.1575 +
 17.1576 +                JCDiagnostic detailsDiag = ((Resolve.ResolveError)refSym).getDiagnostic(JCDiagnostic.DiagnosticType.FRAGMENT,
 17.1577 +                                that, exprType.tsym, exprType, that.name, argtypes, typeargtypes);
 17.1578 +
 17.1579 +                JCDiagnostic.DiagnosticType diagKind = targetError ?
 17.1580 +                        JCDiagnostic.DiagnosticType.FRAGMENT : JCDiagnostic.DiagnosticType.ERROR;
 17.1581 +
 17.1582 +                JCDiagnostic diag = diags.create(diagKind, log.currentSource(), that,
 17.1583 +                        "invalid.mref", Kinds.kindName(that.getMode()), detailsDiag);
 17.1584 +
 17.1585 +                if (targetError) {
 17.1586 +                    resultInfo.checkContext.report(that, diag);
 17.1587 +                } else {
 17.1588 +                    log.report(diag);
 17.1589 +                }
 17.1590 +                result = that.type = types.createErrorType(target);
 17.1591 +                return;
 17.1592 +            }
 17.1593 +
 17.1594 +            if (desc.getReturnType() == Type.recoveryType) {
 17.1595 +                // stop here
 17.1596 +                result = that.type = types.createErrorType(target);
 17.1597 +                return;
 17.1598 +            }
 17.1599 +
 17.1600 +            that.sym = refSym.baseSymbol();
 17.1601 +            that.kind = lookupHelper.referenceKind(that.sym);
 17.1602 +
 17.1603 +            ResultInfo checkInfo =
 17.1604 +                    resultInfo.dup(newMethodTemplate(
 17.1605 +                        desc.getReturnType().tag == VOID ? Type.noType : desc.getReturnType(),
 17.1606 +                        lookupHelper.argtypes,
 17.1607 +                        typeargtypes));
 17.1608 +
 17.1609 +            Type refType = checkId(that, lookupHelper.site, refSym, localEnv, checkInfo);
 17.1610 +
 17.1611 +            if (!refType.isErroneous()) {
 17.1612 +                refType = types.createMethodTypeWithReturn(refType,
 17.1613 +                        adjustMethodReturnType(lookupHelper.site, that.name, checkInfo.pt.getParameterTypes(), refType.getReturnType()));
 17.1614 +            }
 17.1615 +
 17.1616 +            //go ahead with standard method reference compatibility check - note that param check
 17.1617 +            //is a no-op (as this has been taken care during method applicability)
 17.1618 +            boolean isSpeculativeRound =
 17.1619 +                    resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
 17.1620 +            checkReferenceCompatible(that, desc, refType, resultInfo.checkContext, isSpeculativeRound);
 17.1621 +            if (!isSpeculativeRound) {
 17.1622 +                checkAccessibleFunctionalDescriptor(that, localEnv, resultInfo.checkContext.inferenceContext(), desc);
 17.1623 +            }
 17.1624 +            result = check(that, target, VAL, resultInfo);
 17.1625 +        } catch (Types.FunctionDescriptorLookupError ex) {
 17.1626 +            JCDiagnostic cause = ex.getDiagnostic();
 17.1627 +            resultInfo.checkContext.report(that, cause);
 17.1628 +            result = that.type = types.createErrorType(pt());
 17.1629 +            return;
 17.1630 +        }
 17.1631 +    }
 17.1632 +
 17.1633 +    @SuppressWarnings("fallthrough")
 17.1634 +    void checkReferenceCompatible(JCMemberReference tree, Type descriptor, Type refType, CheckContext checkContext, boolean speculativeAttr) {
 17.1635 +        Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType(), types);
 17.1636 +
 17.1637 +        Type resType;
 17.1638 +        switch (tree.getMode()) {
 17.1639 +            case NEW:
 17.1640 +                if (!tree.expr.type.isRaw()) {
 17.1641 +                    resType = tree.expr.type;
 17.1642 +                    break;
 17.1643 +                }
 17.1644 +            default:
 17.1645 +                resType = refType.getReturnType();
 17.1646 +        }
 17.1647 +
 17.1648 +        Type incompatibleReturnType = resType;
 17.1649 +
 17.1650 +        if (returnType.tag == VOID) {
 17.1651 +            incompatibleReturnType = null;
 17.1652 +        }
 17.1653 +
 17.1654 +        if (returnType.tag != VOID && resType.tag != VOID) {
 17.1655 +            if (resType.isErroneous() ||
 17.1656 +                    new LambdaReturnContext(checkContext).compatible(resType, returnType, Warner.noWarnings)) {
 17.1657 +                incompatibleReturnType = null;
 17.1658 +            }
 17.1659 +        }
 17.1660 +
 17.1661 +        if (incompatibleReturnType != null) {
 17.1662 +            checkContext.report(tree, diags.fragment("incompatible.ret.type.in.mref",
 17.1663 +                    diags.fragment("inconvertible.types", resType, descriptor.getReturnType())));
 17.1664 +        }
 17.1665 +
 17.1666 +        if (!speculativeAttr) {
 17.1667 +            List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes(), types);
 17.1668 +            if (chk.unhandled(refType.getThrownTypes(), thrownTypes).nonEmpty()) {
 17.1669 +                log.error(tree, "incompatible.thrown.types.in.mref", refType.getThrownTypes());
 17.1670 +            }
 17.1671 +        }
 17.1672      }
 17.1673  
 17.1674      public void visitParens(JCParens tree) {
 17.1675 @@ -2138,18 +2666,34 @@
 17.1676          result = check(tree, owntype, VAL, resultInfo);
 17.1677      }
 17.1678  
 17.1679 -    public void visitTypeCast(JCTypeCast tree) {
 17.1680 +    public void visitTypeCast(final JCTypeCast tree) {
 17.1681          Type clazztype = attribType(tree.clazz, env);
 17.1682          chk.validate(tree.clazz, env, false);
 17.1683          //a fresh environment is required for 292 inference to work properly ---
 17.1684          //see Infer.instantiatePolymorphicSignatureInstance()
 17.1685          Env<AttrContext> localEnv = env.dup(tree);
 17.1686 -        Type exprtype = attribExpr(tree.expr, localEnv, Infer.anyPoly);
 17.1687 -        Type owntype = chk.checkCastable(tree.expr.pos(), exprtype, clazztype);
 17.1688 +        //should we propagate the target type?
 17.1689 +        final ResultInfo castInfo;
 17.1690 +        final boolean isPoly = TreeInfo.isPoly(tree.expr, tree);
 17.1691 +        if (isPoly) {
 17.1692 +            //expression is a poly - we need to propagate target type info
 17.1693 +            castInfo = new ResultInfo(VAL, clazztype, new Check.NestedCheckContext(resultInfo.checkContext) {
 17.1694 +                @Override
 17.1695 +                public boolean compatible(Type found, Type req, Warner warn) {
 17.1696 +                    return types.isCastable(found, req, warn);
 17.1697 +                }
 17.1698 +            });
 17.1699 +        } else {
 17.1700 +            //standalone cast - target-type info is not propagated
 17.1701 +            castInfo = unknownExprInfo;
 17.1702 +        }
 17.1703 +        Type exprtype = attribTree(tree.expr, localEnv, castInfo);
 17.1704 +        Type owntype = isPoly ? clazztype : chk.checkCastable(tree.expr.pos(), exprtype, clazztype);
 17.1705          if (exprtype.constValue() != null)
 17.1706              owntype = cfolder.coerce(exprtype, owntype);
 17.1707          result = check(tree, capture(owntype), VAL, resultInfo);
 17.1708 -        chk.checkRedundantCast(localEnv, tree);
 17.1709 +        if (!isPoly)
 17.1710 +            chk.checkRedundantCast(localEnv, tree);
 17.1711      }
 17.1712  
 17.1713      public void visitTypeTest(JCInstanceOf tree) {
 17.1714 @@ -2176,15 +2720,13 @@
 17.1715  
 17.1716      public void visitIdent(JCIdent tree) {
 17.1717          Symbol sym;
 17.1718 -        boolean varArgs = false;
 17.1719  
 17.1720          // Find symbol
 17.1721          if (pt().tag == METHOD || pt().tag == FORALL) {
 17.1722              // If we are looking for a method, the prototype `pt' will be a
 17.1723              // method type with the type of the call's arguments as parameters.
 17.1724 -            env.info.varArgs = false;
 17.1725 +            env.info.pendingResolutionPhase = null;
 17.1726              sym = rs.resolveMethod(tree.pos(), env, tree.name, pt().getParameterTypes(), pt().getTypeArguments());
 17.1727 -            varArgs = env.info.varArgs;
 17.1728          } else if (tree.sym != null && tree.sym.kind != VAR) {
 17.1729              sym = tree.sym;
 17.1730          } else {
 17.1731 @@ -2246,7 +2788,7 @@
 17.1732              while (env1.outer != null && !rs.isAccessible(env, env1.enclClass.sym.type, sym))
 17.1733                  env1 = env1.outer;
 17.1734          }
 17.1735 -        result = checkId(tree, env1.enclClass.sym.type, sym, env, resultInfo, varArgs);
 17.1736 +        result = checkId(tree, env1.enclClass.sym.type, sym, env, resultInfo);
 17.1737      }
 17.1738  
 17.1739      public void visitSelect(JCFieldAccess tree) {
 17.1740 @@ -2289,13 +2831,13 @@
 17.1741              sitesym.name == names._super;
 17.1742  
 17.1743          // Determine the symbol represented by the selection.
 17.1744 -        env.info.varArgs = false;
 17.1745 +        env.info.pendingResolutionPhase = null;
 17.1746          Symbol sym = selectSym(tree, sitesym, site, env, resultInfo);
 17.1747          if (sym.exists() && !isType(sym) && (pkind() & (PCK | TYP)) != 0) {
 17.1748              site = capture(site);
 17.1749              sym = selectSym(tree, sitesym, site, env, resultInfo);
 17.1750          }
 17.1751 -        boolean varArgs = env.info.varArgs;
 17.1752 +        boolean varArgs = env.info.lastResolveVarargs();
 17.1753          tree.sym = sym;
 17.1754  
 17.1755          if (site.tag == TYPEVAR && !isType(sym) && sym.kind != ERR) {
 17.1756 @@ -2344,9 +2886,10 @@
 17.1757              } else {
 17.1758                  // Check if type-qualified fields or methods are static (JLS)
 17.1759                  if ((sym.flags() & STATIC) == 0 &&
 17.1760 +                    !env.next.tree.hasTag(REFERENCE) &&
 17.1761                      sym.name != names._super &&
 17.1762                      (sym.kind == VAR || sym.kind == MTH)) {
 17.1763 -                    rs.access(rs.new StaticError(sym),
 17.1764 +                    rs.accessBase(rs.new StaticError(sym),
 17.1765                                tree.pos(), site, sym.name, true);
 17.1766                  }
 17.1767              }
 17.1768 @@ -2370,7 +2913,7 @@
 17.1769          }
 17.1770  
 17.1771          env.info.selectSuper = selectSuperPrev;
 17.1772 -        result = checkId(tree, site, sym, env, resultInfo, varArgs);
 17.1773 +        result = checkId(tree, site, sym, env, resultInfo);
 17.1774      }
 17.1775      //where
 17.1776          /** Determine symbol referenced by a Select expression,
 17.1777 @@ -2389,7 +2932,7 @@
 17.1778              Name name = tree.name;
 17.1779              switch (site.tag) {
 17.1780              case PACKAGE:
 17.1781 -                return rs.access(
 17.1782 +                return rs.accessBase(
 17.1783                      rs.findIdentInPackage(env, site.tsym, name, resultInfo.pkind),
 17.1784                      pos, location, site, name, true);
 17.1785              case ARRAY:
 17.1786 @@ -2413,7 +2956,7 @@
 17.1787                      // We are seeing a plain identifier as selector.
 17.1788                      Symbol sym = rs.findIdentInType(env, site, name, resultInfo.pkind);
 17.1789                      if ((resultInfo.pkind & ERRONEOUS) == 0)
 17.1790 -                        sym = rs.access(sym, pos, location, site, name, true);
 17.1791 +                        sym = rs.accessBase(sym, pos, location, site, name, true);
 17.1792                      return sym;
 17.1793                  }
 17.1794              case WILDCARD:
 17.1795 @@ -2435,7 +2978,7 @@
 17.1796                      Symbol sym2 = (sym.flags() & Flags.PRIVATE) != 0 ?
 17.1797                          rs.new AccessError(env, site, sym) :
 17.1798                                  sym;
 17.1799 -                    rs.access(sym2, pos, location, site, name, true);
 17.1800 +                    rs.accessBase(sym2, pos, location, site, name, true);
 17.1801                      return sym;
 17.1802                  }
 17.1803              case ERROR:
 17.1804 @@ -2486,9 +3029,18 @@
 17.1805                       Type site,
 17.1806                       Symbol sym,
 17.1807                       Env<AttrContext> env,
 17.1808 -                     ResultInfo resultInfo,
 17.1809 -                     boolean useVarargs) {
 17.1810 -            if (resultInfo.pt.isErroneous()) return types.createErrorType(site);
 17.1811 +                     ResultInfo resultInfo) {
 17.1812 +            Type pt = resultInfo.pt.tag == FORALL || resultInfo.pt.tag == METHOD ?
 17.1813 +                    resultInfo.pt.map(deferredAttr.new DeferredTypeMap(AttrMode.SPECULATIVE, sym, env.info.pendingResolutionPhase)) :
 17.1814 +                    resultInfo.pt;
 17.1815 +
 17.1816 +            DeferredAttr.DeferredTypeMap recoveryMap =
 17.1817 +                    deferredAttr.new RecoveryDeferredTypeMap(AttrMode.CHECK, sym, env.info.pendingResolutionPhase);
 17.1818 +
 17.1819 +            if (pt.isErroneous()) {
 17.1820 +                Type.map(resultInfo.pt.getParameterTypes(), recoveryMap);
 17.1821 +                return types.createErrorType(site);
 17.1822 +            }
 17.1823              Type owntype; // The computed type of this identifier occurrence.
 17.1824              switch (sym.kind) {
 17.1825              case TYP:
 17.1826 @@ -2563,14 +3115,14 @@
 17.1827                  }
 17.1828                  break;
 17.1829              case MTH: {
 17.1830 -                JCMethodInvocation app = (JCMethodInvocation)env.tree;
 17.1831                  owntype = checkMethod(site, sym,
 17.1832                          new ResultInfo(VAL, resultInfo.pt.getReturnType(), resultInfo.checkContext),
 17.1833 -                        env, app.args, resultInfo.pt.getParameterTypes(),
 17.1834 -                        resultInfo.pt.getTypeArguments(), env.info.varArgs);
 17.1835 +                        env, TreeInfo.args(env.tree), resultInfo.pt.getParameterTypes(),
 17.1836 +                        resultInfo.pt.getTypeArguments());
 17.1837                  break;
 17.1838              }
 17.1839              case PCK: case ERR:
 17.1840 +                Type.map(resultInfo.pt.getParameterTypes(), recoveryMap);
 17.1841                  owntype = sym.type;
 17.1842                  break;
 17.1843              default:
 17.1844 @@ -2710,8 +3262,7 @@
 17.1845                              Env<AttrContext> env,
 17.1846                              final List<JCExpression> argtrees,
 17.1847                              List<Type> argtypes,
 17.1848 -                            List<Type> typeargtypes,
 17.1849 -                            boolean useVarargs) {
 17.1850 +                            List<Type> typeargtypes) {
 17.1851          // Test (5): if symbol is an instance method of a raw type, issue
 17.1852          // an unchecked warning if its argument types change under erasure.
 17.1853          if (allowGenerics &&
 17.1854 @@ -2733,18 +3284,16 @@
 17.1855          // any type arguments and value arguments.
 17.1856          noteWarner.clear();
 17.1857          try {
 17.1858 -            Type owntype = rs.rawInstantiate(
 17.1859 +            Type owntype = rs.checkMethod(
 17.1860                      env,
 17.1861                      site,
 17.1862                      sym,
 17.1863                      resultInfo,
 17.1864                      argtypes,
 17.1865                      typeargtypes,
 17.1866 -                    allowBoxing,
 17.1867 -                    useVarargs,
 17.1868                      noteWarner);
 17.1869  
 17.1870 -            return chk.checkMethod(owntype, sym, env, argtrees, argtypes, useVarargs,
 17.1871 +            return chk.checkMethod(owntype, sym, env, argtrees, argtypes, env.info.lastResolveVarargs(),
 17.1872                      noteWarner.hasNonSilentLint(LintCategory.UNCHECKED));
 17.1873          } catch (Infer.InferenceException ex) {
 17.1874              //invalid target type - propagate exception outwards or report error
 17.1875 @@ -2752,26 +3301,11 @@
 17.1876              resultInfo.checkContext.report(env.tree.pos(), ex.getDiagnostic());
 17.1877              return types.createErrorType(site);
 17.1878          } catch (Resolve.InapplicableMethodException ex) {
 17.1879 -            Assert.error();
 17.1880 +            Assert.error(ex.getDiagnostic().getMessage(Locale.getDefault()));
 17.1881              return null;
 17.1882          }
 17.1883      }
 17.1884  
 17.1885 -    /**
 17.1886 -     * Check that constructor arguments conform to its instantiation.
 17.1887 -     **/
 17.1888 -    public Type checkConstructor(Type site,
 17.1889 -                            Symbol sym,
 17.1890 -                            Env<AttrContext> env,
 17.1891 -                            final List<JCExpression> argtrees,
 17.1892 -                            List<Type> argtypes,
 17.1893 -                            List<Type> typeargtypes,
 17.1894 -                            boolean useVarargs) {
 17.1895 -        Type owntype = checkMethod(site, sym, new ResultInfo(VAL, syms.voidType), env, argtrees, argtypes, typeargtypes, useVarargs);
 17.1896 -        chk.checkType(env.tree.pos(), owntype.getReturnType(), syms.voidType);
 17.1897 -        return owntype;
 17.1898 -    }
 17.1899 -
 17.1900      public void visitLiteral(JCLiteral tree) {
 17.1901          result = check(
 17.1902              tree, litType(tree.typetag).constType(tree.value), VAL, resultInfo);
 17.1903 @@ -3075,8 +3609,10 @@
 17.1904  
 17.1905              Lint prevLint = chk.setLint(env.info.lint);
 17.1906              JavaFileObject prev = log.useSource(c.sourcefile);
 17.1907 +            ResultInfo prevReturnRes = env.info.returnResult;
 17.1908  
 17.1909              try {
 17.1910 +                env.info.returnResult = null;
 17.1911                  // java.lang.Enum may not be subclassed by a non-enum
 17.1912                  if (st.tsym == syms.enumSym &&
 17.1913                      ((c.flags_field & (Flags.ENUM|Flags.COMPOUND)) == 0))
 17.1914 @@ -3093,6 +3629,7 @@
 17.1915  
 17.1916                  chk.checkDeprecatedAnnotation(env.tree.pos(), c);
 17.1917              } finally {
 17.1918 +                env.info.returnResult = prevReturnRes;
 17.1919                  log.useSource(prev);
 17.1920                  chk.setLint(prevLint);
 17.1921              }
 17.1922 @@ -3280,8 +3817,8 @@
 17.1923       * mode (e.g. by an IDE) and the AST contains semantic errors, this routine
 17.1924       * prevents NPE to be progagated during subsequent compilation steps.
 17.1925       */
 17.1926 -    public void postAttr(Env<AttrContext> env) {
 17.1927 -        new PostAttrAnalyzer().scan(env.tree);
 17.1928 +    public void postAttr(JCTree tree) {
 17.1929 +        new PostAttrAnalyzer().scan(tree);
 17.1930      }
 17.1931  
 17.1932      class PostAttrAnalyzer extends TreeScanner {
 17.1933 @@ -3375,6 +3912,14 @@
 17.1934                  that.operator = new OperatorSymbol(names.empty, syms.unknownType, -1, syms.noSymbol);
 17.1935              super.visitUnary(that);
 17.1936          }
 17.1937 +
 17.1938 +        @Override
 17.1939 +        public void visitReference(JCMemberReference that) {
 17.1940 +            super.visitReference(that);
 17.1941 +            if (that.sym == null) {
 17.1942 +                that.sym = new MethodSymbol(0, names.empty, syms.unknownType, syms.noSymbol);
 17.1943 +            }
 17.1944 +        }
 17.1945      }
 17.1946      // </editor-fold>
 17.1947  }

    18.1 --- a/src/share/classes/com/sun/tools/javac/comp/AttrContext.java	Thu Oct 11 09:50:52 2012 -0700
    18.2 +++ b/src/share/classes/com/sun/tools/javac/comp/AttrContext.java	Thu Oct 11 17:00:54 2012 -0700
    18.3 @@ -56,7 +56,7 @@
    18.4  
    18.5      /** Are arguments to current function applications boxed into an array for varargs?
    18.6       */
    18.7 -    boolean varArgs = false;
    18.8 +    Resolve.MethodResolutionPhase pendingResolutionPhase = null;
    18.9  
   18.10      /** A record of the lint/SuppressWarnings currently in effect
   18.11       */
   18.12 @@ -67,6 +67,11 @@
   18.13       */
   18.14      Symbol enclVar = null;
   18.15  
   18.16 +    /** ResultInfo to be used for attributing 'return' statement expressions
   18.17 +     * (set by Attr.visitMethod and Attr.visitLambda)
   18.18 +     */
   18.19 +    Attr.ResultInfo returnResult = null;
   18.20 +
   18.21      /** Duplicate this context, replacing scope field and copying all others.
   18.22       */
   18.23      AttrContext dup(Scope scope) {
   18.24 @@ -75,9 +80,10 @@
   18.25          info.staticLevel = staticLevel;
   18.26          info.isSelfCall = isSelfCall;
   18.27          info.selectSuper = selectSuper;
   18.28 -        info.varArgs = varArgs;
   18.29 +        info.pendingResolutionPhase = pendingResolutionPhase;
   18.30          info.lint = lint;
   18.31          info.enclVar = enclVar;
   18.32 +        info.returnResult = returnResult;
   18.33          return info;
   18.34      }
   18.35  
   18.36 @@ -93,6 +99,11 @@
   18.37          return scope.getElements();
   18.38      }
   18.39  
   18.40 +    boolean lastResolveVarargs() {
   18.41 +        return pendingResolutionPhase != null &&
   18.42 +                pendingResolutionPhase.isVarargsRequired();
   18.43 +    }
   18.44 +
   18.45      public String toString() {
   18.46          return "AttrContext[" + scope.toString() + "]";
   18.47      }

    19.1 --- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Thu Oct 11 09:50:52 2012 -0700
    19.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Thu Oct 11 17:00:54 2012 -0700
    19.3 @@ -40,6 +40,9 @@
    19.4  import com.sun.tools.javac.code.Lint.LintCategory;
    19.5  import com.sun.tools.javac.code.Type.*;
    19.6  import com.sun.tools.javac.code.Symbol.*;
    19.7 +import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;
    19.8 +import com.sun.tools.javac.comp.Infer.InferenceContext;
    19.9 +import com.sun.tools.javac.comp.Infer.InferenceContext.FreeTypeListener;
   19.10  
   19.11  import static com.sun.tools.javac.code.Flags.*;
   19.12  import static com.sun.tools.javac.code.Flags.ANNOTATION;
   19.13 @@ -66,6 +69,7 @@
   19.14      private final Resolve rs;
   19.15      private final Symtab syms;
   19.16      private final Enter enter;
   19.17 +    private final DeferredAttr deferredAttr;
   19.18      private final Infer infer;
   19.19      private final Types types;
   19.20      private final JCDiagnostic.Factory diags;
   19.21 @@ -98,6 +102,7 @@
   19.22          rs = Resolve.instance(context);
   19.23          syms = Symtab.instance(context);
   19.24          enter = Enter.instance(context);
   19.25 +        deferredAttr = DeferredAttr.instance(context);
   19.26          infer = Infer.instance(context);
   19.27          this.types = Types.instance(context);
   19.28          diags = JCDiagnostic.Factory.instance(context);
   19.29 @@ -416,7 +421,7 @@
   19.30       * checks - depending on the check context, meaning of 'compatibility' might
   19.31       * vary significantly.
   19.32       */
   19.33 -    interface CheckContext {
   19.34 +    public interface CheckContext {
   19.35          /**
   19.36           * Is type 'found' compatible with type 'req' in given context
   19.37           */
   19.38 @@ -429,6 +434,12 @@
   19.39           * Obtain a warner for this check context
   19.40           */
   19.41          public Warner checkWarner(DiagnosticPosition pos, Type found, Type req);
   19.42 +
   19.43 +        public Infer.InferenceContext inferenceContext();
   19.44 +
   19.45 +        public DeferredAttr.DeferredAttrContext deferredAttrContext();
   19.46 +
   19.47 +        public boolean allowBoxing();
   19.48      }
   19.49  
   19.50      /**
   19.51 @@ -455,6 +466,18 @@
   19.52          public Warner checkWarner(DiagnosticPosition pos, Type found, Type req) {
   19.53              return enclosingContext.checkWarner(pos, found, req);
   19.54          }
   19.55 +
   19.56 +        public Infer.InferenceContext inferenceContext() {
   19.57 +            return enclosingContext.inferenceContext();
   19.58 +        }
   19.59 +
   19.60 +        public DeferredAttrContext deferredAttrContext() {
   19.61 +            return enclosingContext.deferredAttrContext();
   19.62 +        }
   19.63 +
   19.64 +        public boolean allowBoxing() {
   19.65 +            return enclosingContext.allowBoxing();
   19.66 +        }
   19.67      }
   19.68  
   19.69      /**
   19.70 @@ -471,6 +494,18 @@
   19.71          public Warner checkWarner(DiagnosticPosition pos, Type found, Type req) {
   19.72              return convertWarner(pos, found, req);
   19.73          }
   19.74 +
   19.75 +        public InferenceContext inferenceContext() {
   19.76 +            return infer.emptyContext;
   19.77 +        }
   19.78 +
   19.79 +        public DeferredAttrContext deferredAttrContext() {
   19.80 +            return deferredAttr.emptyDeferredAttrContext;
   19.81 +        }
   19.82 +
   19.83 +        public boolean allowBoxing() {
   19.84 +            return true;
   19.85 +        }
   19.86      };
   19.87  
   19.88      /** Check that a given type is assignable to a given proto-type.
   19.89 @@ -483,7 +518,16 @@
   19.90          return checkType(pos, found, req, basicHandler);
   19.91      }
   19.92  
   19.93 -    Type checkType(final DiagnosticPosition pos, Type found, Type req, CheckContext checkContext) {
   19.94 +    Type checkType(final DiagnosticPosition pos, final Type found, final Type req, final CheckContext checkContext) {
   19.95 +        final Infer.InferenceContext inferenceContext = checkContext.inferenceContext();
   19.96 +        if (inferenceContext.free(req)) {
   19.97 +            inferenceContext.addFreeTypeListener(List.of(req), new FreeTypeListener() {
   19.98 +                @Override
   19.99 +                public void typesInferred(InferenceContext inferenceContext) {
  19.100 +                    checkType(pos, found, inferenceContext.asInstType(req, types), checkContext);
  19.101 +                }
  19.102 +            });
  19.103 +        }
  19.104          if (req.tag == ERROR)
  19.105              return req;
  19.106          if (req.tag == NONE)
  19.107 @@ -523,9 +567,9 @@
  19.108       */
  19.109      public void checkRedundantCast(Env<AttrContext> env, JCTypeCast tree) {
  19.110          if (!tree.type.isErroneous() &&
  19.111 -            (env.info.lint == null || env.info.lint.isEnabled(Lint.LintCategory.CAST))
  19.112 -            && types.isSameType(tree.expr.type, tree.clazz.type)
  19.113 -            && !is292targetTypeCast(tree)) {
  19.114 +                (env.info.lint == null || env.info.lint.isEnabled(Lint.LintCategory.CAST))
  19.115 +                && types.isSameType(tree.expr.type, tree.clazz.type)
  19.116 +                && !is292targetTypeCast(tree)) {
  19.117              log.warning(Lint.LintCategory.CAST,
  19.118                      tree.pos(), "redundant.cast", tree.expr.type);
  19.119          }
  19.120 @@ -604,6 +648,22 @@
  19.121              return t;
  19.122      }
  19.123  
  19.124 +    /** Check that type is a valid qualifier for a constructor reference expression
  19.125 +     */
  19.126 +    Type checkConstructorRefType(DiagnosticPosition pos, Type t) {
  19.127 +        t = checkClassType(pos, t);
  19.128 +        if (t.tag == CLASS) {
  19.129 +            if ((t.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
  19.130 +                log.error(pos, "abstract.cant.be.instantiated");
  19.131 +                t = types.createErrorType(t);
  19.132 +            } else if ((t.tsym.flags() & ENUM) != 0) {
  19.133 +                log.error(pos, "enum.cant.be.instantiated");
  19.134 +                t = types.createErrorType(t);
  19.135 +            }
  19.136 +        }
  19.137 +        return t;
  19.138 +    }
  19.139 +
  19.140      /** Check that type is a class or interface type.
  19.141       *  @param pos           Position to be used for error reporting.
  19.142       *  @param t             The type to be checked.
  19.143 @@ -796,29 +856,34 @@
  19.144                  sym.owner == syms.enumSym)
  19.145                  formals = formals.tail.tail;
  19.146          List<JCExpression> args = argtrees;
  19.147 -        while (formals.head != last) {
  19.148 -            JCTree arg = args.head;
  19.149 -            Warner warn = convertWarner(arg.pos(), arg.type, formals.head);
  19.150 -            assertConvertible(arg, arg.type, formals.head, warn);
  19.151 -            args = args.tail;
  19.152 -            formals = formals.tail;
  19.153 -        }
  19.154 -        if (useVarargs) {
  19.155 -            Type varArg = types.elemtype(last);
  19.156 -            while (args.tail != null) {
  19.157 +        DeferredAttr.DeferredTypeMap checkDeferredMap =
  19.158 +                deferredAttr.new DeferredTypeMap(DeferredAttr.AttrMode.CHECK, sym, env.info.pendingResolutionPhase);
  19.159 +        if (args != null) {
  19.160 +            //this is null when type-checking a method reference
  19.161 +            while (formals.head != last) {
  19.162                  JCTree arg = args.head;
  19.163 -                Warner warn = convertWarner(arg.pos(), arg.type, varArg);
  19.164 -                assertConvertible(arg, arg.type, varArg, warn);
  19.165 +                Warner warn = convertWarner(arg.pos(), arg.type, formals.head);
  19.166 +                assertConvertible(arg, arg.type, formals.head, warn);
  19.167                  args = args.tail;
  19.168 +                formals = formals.tail;
  19.169              }
  19.170 -        } else if ((sym.flags() & VARARGS) != 0 && allowVarargs) {
  19.171 -            // non-varargs call to varargs method
  19.172 -            Type varParam = owntype.getParameterTypes().last();
  19.173 -            Type lastArg = argtypes.last();
  19.174 -            if (types.isSubtypeUnchecked(lastArg, types.elemtype(varParam)) &&
  19.175 -                    !types.isSameType(types.erasure(varParam), types.erasure(lastArg)))
  19.176 -                log.warning(argtrees.last().pos(), "inexact.non-varargs.call",
  19.177 -                        types.elemtype(varParam), varParam);
  19.178 +            if (useVarargs) {
  19.179 +                Type varArg = types.elemtype(last);
  19.180 +                while (args.tail != null) {
  19.181 +                    JCTree arg = args.head;
  19.182 +                    Warner warn = convertWarner(arg.pos(), arg.type, varArg);
  19.183 +                    assertConvertible(arg, arg.type, varArg, warn);
  19.184 +                    args = args.tail;
  19.185 +                }
  19.186 +            } else if ((sym.flags() & VARARGS) != 0 && allowVarargs) {
  19.187 +                // non-varargs call to varargs method
  19.188 +                Type varParam = owntype.getParameterTypes().last();
  19.189 +                Type lastArg = checkDeferredMap.apply(argtypes.last());
  19.190 +                if (types.isSubtypeUnchecked(lastArg, types.elemtype(varParam)) &&
  19.191 +                        !types.isSameType(types.erasure(varParam), types.erasure(lastArg)))
  19.192 +                    log.warning(argtrees.last().pos(), "inexact.non-varargs.call",
  19.193 +                            types.elemtype(varParam), varParam);
  19.194 +            }
  19.195          }
  19.196          if (unchecked) {
  19.197              warnUnchecked(env.tree.pos(),
  19.198 @@ -826,7 +891,7 @@
  19.199                      kindName(sym),
  19.200                      sym.name,
  19.201                      rs.methodArguments(sym.type.getParameterTypes()),
  19.202 -                    rs.methodArguments(argtypes),
  19.203 +                    rs.methodArguments(Type.map(argtypes, checkDeferredMap)),
  19.204                      kindName(sym.location()),
  19.205                      sym.location());
  19.206             owntype = new MethodType(owntype.getParameterTypes(),
  19.207 @@ -853,6 +918,9 @@
  19.208                  case NEWCLASS:
  19.209                      ((JCNewClass) tree).varargsElement = elemtype;
  19.210                      break;
  19.211 +                case REFERENCE:
  19.212 +                    ((JCMemberReference) tree).varargsElement = elemtype;
  19.213 +                    break;
  19.214                  default:
  19.215                      throw new AssertionError(""+tree);
  19.216              }
  19.217 @@ -870,6 +938,65 @@
  19.218                  return;
  19.219          }
  19.220  
  19.221 +        void checkAccessibleFunctionalDescriptor(DiagnosticPosition pos, Env<AttrContext> env, Type desc) {
  19.222 +            AccessChecker accessChecker = new AccessChecker(env);
  19.223 +            //check args accessibility (only if implicit parameter types)
  19.224 +            for (Type arg : desc.getParameterTypes()) {
  19.225 +                if (!accessChecker.visit(arg)) {
  19.226 +                    log.error(pos, "cant.access.arg.type.in.functional.desc", arg);
  19.227 +                    return;
  19.228 +                }
  19.229 +            }
  19.230 +            //check return type accessibility
  19.231 +            if (!accessChecker.visit(desc.getReturnType())) {
  19.232 +                log.error(pos, "cant.access.return.in.functional.desc", desc.getReturnType());
  19.233 +                return;
  19.234 +            }
  19.235 +            //check thrown types accessibility
  19.236 +            for (Type thrown : desc.getThrownTypes()) {
  19.237 +                if (!accessChecker.visit(thrown)) {
  19.238 +                    log.error(pos, "cant.access.thrown.in.functional.desc", thrown);
  19.239 +                    return;
  19.240 +                }
  19.241 +            }
  19.242 +        }
  19.243 +
  19.244 +        class AccessChecker extends Types.UnaryVisitor<Boolean> {
  19.245 +
  19.246 +            Env<AttrContext> env;
  19.247 +
  19.248 +            AccessChecker(Env<AttrContext> env) {
  19.249 +                this.env = env;
  19.250 +            }
  19.251 +
  19.252 +            Boolean visit(List<Type> ts) {
  19.253 +                for (Type t : ts) {
  19.254 +                    if (!visit(t))
  19.255 +                        return false;
  19.256 +                }
  19.257 +                return true;
  19.258 +            }
  19.259 +
  19.260 +            public Boolean visitType(Type t, Void s) {
  19.261 +                return true;
  19.262 +            }
  19.263 +
  19.264 +            @Override
  19.265 +            public Boolean visitArrayType(ArrayType t, Void s) {
  19.266 +                return visit(t.elemtype);
  19.267 +            }
  19.268 +
  19.269 +            @Override
  19.270 +            public Boolean visitClassType(ClassType t, Void s) {
  19.271 +                return rs.isAccessible(env, t, true) &&
  19.272 +                        visit(t.getTypeArguments());
  19.273 +            }
  19.274 +
  19.275 +            @Override
  19.276 +            public Boolean visitWildcardType(WildcardType t, Void s) {
  19.277 +                return visit(t.type);
  19.278 +            }
  19.279 +        };
  19.280      /**
  19.281       * Check that type 't' is a valid instantiation of a generic class
  19.282       * (see JLS 4.5)
  19.283 @@ -2470,6 +2597,7 @@
  19.284          validateDocumented(t.tsym, s, pos);
  19.285          validateInherited(t.tsym, s, pos);
  19.286          validateTarget(t.tsym, s, pos);
  19.287 +        validateDefault(t.tsym, s, pos);
  19.288      }
  19.289  
  19.290      /**
  19.291 @@ -2650,6 +2778,21 @@
  19.292          return true;
  19.293      }
  19.294  
  19.295 +    private void validateDefault(Symbol container, Symbol contained, DiagnosticPosition pos) {
  19.296 +        // validate that all other elements of containing type has defaults
  19.297 +        Scope scope = container.members();
  19.298 +        for(Symbol elm : scope.getElements()) {
  19.299 +            if (elm.name != names.value &&
  19.300 +                elm.kind == Kinds.MTH &&
  19.301 +                ((MethodSymbol)elm).defaultValue == null) {
  19.302 +                log.error(pos,
  19.303 +                          "invalid.containedby.annotation.elem.nondefault",
  19.304 +                          container,
  19.305 +                          elm);
  19.306 +            }
  19.307 +        }
  19.308 +    }
  19.309 +
  19.310      /** Is s a method symbol that overrides a method in a superclass? */
  19.311      boolean isOverrider(Symbol s) {
  19.312          if (s.kind != MTH || s.isStatic())

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Thu Oct 11 17:00:54 2012 -0700
    20.3 @@ -0,0 +1,640 @@
    20.4 +/*
    20.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    20.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    20.7 + *
    20.8 + * This code is free software; you can redistribute it and/or modify it
    20.9 + * under the terms of the GNU General Public License version 2 only, as
   20.10 + * published by the Free Software Foundation.  Oracle designates this
   20.11 + * particular file as subject to the "Classpath" exception as provided
   20.12 + * by Oracle in the LICENSE file that accompanied this code.
   20.13 + *
   20.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   20.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   20.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   20.17 + * version 2 for more details (a copy is included in the LICENSE file that
   20.18 + * accompanied this code).
   20.19 + *
   20.20 + * You should have received a copy of the GNU General Public License version
   20.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   20.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20.23 + *
   20.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   20.25 + * or visit www.oracle.com if you need additional information or have any
   20.26 + * questions.
   20.27 + */
   20.28 +
   20.29 +package com.sun.tools.javac.comp;
   20.30 +
   20.31 +import com.sun.tools.javac.code.*;
   20.32 +import com.sun.tools.javac.tree.*;
   20.33 +import com.sun.tools.javac.util.*;
   20.34 +import com.sun.tools.javac.code.Symbol.*;
   20.35 +import com.sun.tools.javac.code.Type.*;
   20.36 +import com.sun.tools.javac.comp.Attr.ResultInfo;
   20.37 +import com.sun.tools.javac.comp.Infer.InferenceContext;
   20.38 +import com.sun.tools.javac.comp.Resolve.MethodResolutionPhase;
   20.39 +import com.sun.tools.javac.tree.JCTree.*;
   20.40 +
   20.41 +import javax.tools.JavaFileObject;
   20.42 +
   20.43 +import java.util.ArrayList;
   20.44 +import java.util.HashSet;
   20.45 +import java.util.Map;
   20.46 +import java.util.Queue;
   20.47 +import java.util.Set;
   20.48 +import java.util.WeakHashMap;
   20.49 +
   20.50 +import static com.sun.tools.javac.code.TypeTags.*;
   20.51 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
   20.52 +import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
   20.53 +
   20.54 +/**
   20.55 + * This is an helper class that is used to perform deferred type-analysis.
   20.56 + * Each time a poly expression occurs in argument position, javac attributes it
   20.57 + * with a temporary 'deferred type' that is checked (possibly multiple times)
   20.58 + * against an expected formal type.
   20.59 + *
   20.60 + *  <p><b>This is NOT part of any supported API.
   20.61 + *  If you write code that depends on this, you do so at your own risk.
   20.62 + *  This code and its internal interfaces are subject to change or
   20.63 + *  deletion without notice.</b>
   20.64 + */
   20.65 +public class DeferredAttr extends JCTree.Visitor {
   20.66 +    protected static final Context.Key<DeferredAttr> deferredAttrKey =
   20.67 +        new Context.Key<DeferredAttr>();
   20.68 +
   20.69 +    final Attr attr;
   20.70 +    final Check chk;
   20.71 +    final Enter enter;
   20.72 +    final Infer infer;
   20.73 +    final Log log;
   20.74 +    final Symtab syms;
   20.75 +    final TreeMaker make;
   20.76 +    final Types types;
   20.77 +
   20.78 +    public static DeferredAttr instance(Context context) {
   20.79 +        DeferredAttr instance = context.get(deferredAttrKey);
   20.80 +        if (instance == null)
   20.81 +            instance = new DeferredAttr(context);
   20.82 +        return instance;
   20.83 +    }
   20.84 +
   20.85 +    protected DeferredAttr(Context context) {
   20.86 +        context.put(deferredAttrKey, this);
   20.87 +        attr = Attr.instance(context);
   20.88 +        chk = Check.instance(context);
   20.89 +        enter = Enter.instance(context);
   20.90 +        infer = Infer.instance(context);
   20.91 +        log = Log.instance(context);
   20.92 +        syms = Symtab.instance(context);
   20.93 +        make = TreeMaker.instance(context);
   20.94 +        types = Types.instance(context);
   20.95 +    }
   20.96 +
   20.97 +    /**
   20.98 +     * This type represents a deferred type. A deferred type starts off with
   20.99 +     * no information on the underlying expression type. Such info needs to be
  20.100 +     * discovered through type-checking the deferred type against a target-type.
  20.101 +     * Every deferred type keeps a pointer to the AST node from which it originated.
  20.102 +     */
  20.103 +    public class DeferredType extends Type {
  20.104 +
  20.105 +        public JCExpression tree;
  20.106 +        Env<AttrContext> env;
  20.107 +        AttrMode mode;
  20.108 +        SpeculativeCache speculativeCache;
  20.109 +
  20.110 +        DeferredType(JCExpression tree, Env<AttrContext> env) {
  20.111 +            super(DEFERRED, null);
  20.112 +            this.tree = tree;
  20.113 +            this.env = env.dup(tree, env.info.dup());
  20.114 +            this.speculativeCache = new SpeculativeCache();
  20.115 +        }
  20.116 +
  20.117 +        /**
  20.118 +         * A speculative cache is used to keep track of all overload resolution rounds
  20.119 +         * that triggered speculative attribution on a given deferred type. Each entry
  20.120 +         * stores a pointer to the speculative tree and the resolution phase in which the entry
  20.121 +         * has been added.
  20.122 +         */
  20.123 +        class SpeculativeCache {
  20.124 +
  20.125 +            private Map<Symbol, List<Entry>> cache =
  20.126 +                    new WeakHashMap<Symbol, List<Entry>>();
  20.127 +
  20.128 +            class Entry {
  20.129 +                JCTree speculativeTree;
  20.130 +                Resolve.MethodResolutionPhase phase;
  20.131 +
  20.132 +                public Entry(JCTree speculativeTree, MethodResolutionPhase phase) {
  20.133 +                    this.speculativeTree = speculativeTree;
  20.134 +                    this.phase = phase;
  20.135 +                }
  20.136 +
  20.137 +                boolean matches(Resolve.MethodResolutionPhase phase) {
  20.138 +                    return this.phase == phase;
  20.139 +                }
  20.140 +            }
  20.141 +
  20.142 +            /**
  20.143 +             * Clone a speculative cache entry as a fresh entry associated
  20.144 +             * with a new method (this maybe required to fixup speculative cache
  20.145 +             * misses after Resolve.access())
  20.146 +             */
  20.147 +            void dupAllTo(Symbol from, Symbol to) {
  20.148 +                Assert.check(cache.get(to) == null);
  20.149 +                List<Entry> entries = cache.get(from);
  20.150 +                if (entries != null) {
  20.151 +                    cache.put(to, entries);
  20.152 +                }
  20.153 +            }
  20.154 +
  20.155 +            /**
  20.156 +             * Retrieve a speculative cache entry corresponding to given symbol
  20.157 +             * and resolution phase
  20.158 +             */
  20.159 +            Entry get(Symbol msym, MethodResolutionPhase phase) {
  20.160 +                List<Entry> entries = cache.get(msym);
  20.161 +                if (entries == null) return null;
  20.162 +                for (Entry e : entries) {
  20.163 +                    if (e.matches(phase)) return e;
  20.164 +                }
  20.165 +                return null;
  20.166 +            }
  20.167 +
  20.168 +            /**
  20.169 +             * Stores a speculative cache entry corresponding to given symbol
  20.170 +             * and resolution phase
  20.171 +             */
  20.172 +            void put(Symbol msym, JCTree speculativeTree, MethodResolutionPhase phase) {
  20.173 +                List<Entry> entries = cache.get(msym);
  20.174 +                if (entries == null) {
  20.175 +                    entries = List.nil();
  20.176 +                }
  20.177 +                cache.put(msym, entries.prepend(new Entry(speculativeTree, phase)));
  20.178 +            }
  20.179 +        }
  20.180 +
  20.181 +        /**
  20.182 +         * Get the type that has been computed during a speculative attribution round
  20.183 +         */
  20.184 +        Type speculativeType(Symbol msym, MethodResolutionPhase phase) {
  20.185 +            SpeculativeCache.Entry e = speculativeCache.get(msym, phase);
  20.186 +            return e != null ? e.speculativeTree.type : Type.noType;
  20.187 +        }
  20.188 +
  20.189 +        /**
  20.190 +         * Check a deferred type against a potential target-type. Depending on
  20.191 +         * the current attribution mode, a normal vs. speculative attribution
  20.192 +         * round is performed on the underlying AST node. There can be only one
  20.193 +         * speculative round for a given target method symbol; moreover, a normal
  20.194 +         * attribution round must follow one or more speculative rounds.
  20.195 +         */
  20.196 +        Type check(ResultInfo resultInfo) {
  20.197 +            DeferredAttrContext deferredAttrContext =
  20.198 +                    resultInfo.checkContext.deferredAttrContext();
  20.199 +            Assert.check(deferredAttrContext != emptyDeferredAttrContext);
  20.200 +            List<Type> stuckVars = stuckVars(tree, resultInfo);
  20.201 +            if (stuckVars.nonEmpty()) {
  20.202 +                deferredAttrContext.addDeferredAttrNode(this, resultInfo, stuckVars);
  20.203 +                return Type.noType;
  20.204 +            } else {
  20.205 +                try {
  20.206 +                    switch (deferredAttrContext.mode) {
  20.207 +                        case SPECULATIVE:
  20.208 +                            Assert.check(mode == null ||
  20.209 +                                    (mode == AttrMode.SPECULATIVE &&
  20.210 +                                    speculativeType(deferredAttrContext.msym, deferredAttrContext.phase).tag == NONE));
  20.211 +                            JCTree speculativeTree = attribSpeculative(tree, env, resultInfo);
  20.212 +                            speculativeCache.put(deferredAttrContext.msym, speculativeTree, deferredAttrContext.phase);
  20.213 +                            return speculativeTree.type;
  20.214 +                        case CHECK:
  20.215 +                            Assert.check(mode == AttrMode.SPECULATIVE);
  20.216 +                            return attr.attribTree(tree, env, resultInfo);
  20.217 +                    }
  20.218 +                    Assert.error();
  20.219 +                    return null;
  20.220 +                } finally {
  20.221 +                    mode = deferredAttrContext.mode;
  20.222 +                }
  20.223 +            }
  20.224 +        }
  20.225 +    }
  20.226 +
  20.227 +    /**
  20.228 +     * The 'mode' in which the deferred type is to be type-checked
  20.229 +     */
  20.230 +    public enum AttrMode {
  20.231 +        /**
  20.232 +         * A speculative type-checking round is used during overload resolution
  20.233 +         * mainly to generate constraints on inference variables. Side-effects
  20.234 +         * arising from type-checking the expression associated with the deferred
  20.235 +         * type are reversed after the speculative round finishes. This means the
  20.236 +         * expression tree will be left in a blank state.
  20.237 +         */
  20.238 +        SPECULATIVE,
  20.239 +        /**
  20.240 +         * This is the plain type-checking mode. Produces side-effects on the underlying AST node
  20.241 +         */
  20.242 +        CHECK;
  20.243 +    }
  20.244 +
  20.245 +    /**
  20.246 +     * Routine that performs speculative type-checking; the input AST node is
  20.247 +     * cloned (to avoid side-effects cause by Attr) and compiler state is
  20.248 +     * restored after type-checking. All diagnostics (but critical ones) are
  20.249 +     * disabled during speculative type-checking.
  20.250 +     */
  20.251 +    JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
  20.252 +        JCTree newTree = new TreeCopier<Object>(make).copy(tree);
  20.253 +        Env<AttrContext> speculativeEnv = env.dup(newTree, env.info.dup(env.info.scope.dupUnshared()));
  20.254 +        speculativeEnv.info.scope.owner = env.info.scope.owner;
  20.255 +        Filter<JCDiagnostic> prevDeferDiagsFilter = log.deferredDiagFilter;
  20.256 +        Queue<JCDiagnostic> prevDeferredDiags = log.deferredDiagnostics;
  20.257 +        final JavaFileObject currentSource = log.currentSourceFile();
  20.258 +        try {
  20.259 +            log.deferredDiagnostics = new ListBuffer<JCDiagnostic>();
  20.260 +            log.deferredDiagFilter = new Filter<JCDiagnostic>() {
  20.261 +                public boolean accepts(JCDiagnostic t) {
  20.262 +                    return t.getDiagnosticSource().getFile().equals(currentSource);
  20.263 +                }
  20.264 +            };
  20.265 +            attr.attribTree(newTree, speculativeEnv, resultInfo);
  20.266 +            unenterScanner.scan(newTree);
  20.267 +            return newTree;
  20.268 +        } catch (Abort ex) {
  20.269 +            //if some very bad condition occurred during deferred attribution
  20.270 +            //we should dump all errors before killing javac
  20.271 +            log.reportDeferredDiagnostics();
  20.272 +            throw ex;
  20.273 +        } finally {
  20.274 +            unenterScanner.scan(newTree);
  20.275 +            log.deferredDiagFilter = prevDeferDiagsFilter;
  20.276 +            log.deferredDiagnostics = prevDeferredDiags;
  20.277 +        }
  20.278 +    }
  20.279 +    //where
  20.280 +        protected TreeScanner unenterScanner = new TreeScanner() {
  20.281 +            @Override
  20.282 +            public void visitClassDef(JCClassDecl tree) {
  20.283 +                ClassSymbol csym = tree.sym;
  20.284 +                enter.typeEnvs.remove(csym);
  20.285 +                chk.compiled.remove(csym.flatname);
  20.286 +                syms.classes.remove(csym.flatname);
  20.287 +                super.visitClassDef(tree);
  20.288 +            }
  20.289 +        };
  20.290 +
  20.291 +    /**
  20.292 +     * A deferred context is created on each method check. A deferred context is
  20.293 +     * used to keep track of information associated with the method check, such as
  20.294 +     * the symbol of the method being checked, the overload resolution phase,
  20.295 +     * the kind of attribution mode to be applied to deferred types and so forth.
  20.296 +     * As deferred types are processed (by the method check routine) stuck AST nodes
  20.297 +     * are added (as new deferred attribution nodes) to this context. The complete()
  20.298 +     * routine makes sure that all pending nodes are properly processed, by
  20.299 +     * progressively instantiating all inference variables on which one or more
  20.300 +     * deferred attribution node is stuck.
  20.301 +     */
  20.302 +    class DeferredAttrContext {
  20.303 +
  20.304 +        /** attribution mode */
  20.305 +        final AttrMode mode;
  20.306 +
  20.307 +        /** symbol of the method being checked */
  20.308 +        final Symbol msym;
  20.309 +
  20.310 +        /** method resolution step */
  20.311 +        final Resolve.MethodResolutionPhase phase;
  20.312 +
  20.313 +        /** inference context */
  20.314 +        final InferenceContext inferenceContext;
  20.315 +
  20.316 +        /** list of deferred attribution nodes to be processed */
  20.317 +        ArrayList<DeferredAttrNode> deferredAttrNodes = new ArrayList<DeferredAttrNode>();
  20.318 +
  20.319 +        DeferredAttrContext(AttrMode mode, Symbol msym, MethodResolutionPhase phase, InferenceContext inferenceContext) {
  20.320 +            this.mode = mode;
  20.321 +            this.msym = msym;
  20.322 +            this.phase = phase;
  20.323 +            this.inferenceContext = inferenceContext;
  20.324 +        }
  20.325 +
  20.326 +        /**
  20.327 +         * Adds a node to the list of deferred attribution nodes - used by Resolve.rawCheckArgumentsApplicable
  20.328 +         * Nodes added this way act as 'roots' for the out-of-order method checking process.
  20.329 +         */
  20.330 +        void addDeferredAttrNode(final DeferredType dt, ResultInfo resultInfo, List<Type> stuckVars) {
  20.331 +            deferredAttrNodes.add(new DeferredAttrNode(dt, resultInfo, stuckVars));
  20.332 +        }
  20.333 +
  20.334 +        /**
  20.335 +         * Incrementally process all nodes, by skipping 'stuck' nodes and attributing
  20.336 +         * 'unstuck' ones. If at any point no progress can be made (no 'unstuck' nodes)
  20.337 +         * some inference variable might get eagerly instantiated so that all nodes
  20.338 +         * can be type-checked.
  20.339 +         */
  20.340 +        void complete() {
  20.341 +            while (!deferredAttrNodes.isEmpty()) {
  20.342 +                Set<Type> stuckVars = new HashSet<Type>();
  20.343 +                boolean progress = false;
  20.344 +                //scan a defensive copy of the node list - this is because a deferred
  20.345 +                //attribution round can add new nodes to the list
  20.346 +                for (DeferredAttrNode deferredAttrNode : List.from(deferredAttrNodes)) {
  20.347 +                    if (!deferredAttrNode.isStuck()) {
  20.348 +                        deferredAttrNode.process();
  20.349 +                        deferredAttrNodes.remove(deferredAttrNode);
  20.350 +                        progress = true;
  20.351 +                    } else {
  20.352 +                        stuckVars.addAll(deferredAttrNode.stuckVars);
  20.353 +                    }
  20.354 +                }
  20.355 +                if (!progress) {
  20.356 +                    //remove all variables that have already been instantiated
  20.357 +                    //from the list of stuck variables
  20.358 +                    inferenceContext.solveAny(inferenceContext.freeVarsIn(List.from(stuckVars)), types, infer);
  20.359 +                    inferenceContext.notifyChange(types);
  20.360 +                }
  20.361 +            }
  20.362 +        }
  20.363 +
  20.364 +        /**
  20.365 +         * Class representing a deferred attribution node. It keeps track of
  20.366 +         * a deferred type, along with the expected target type information.
  20.367 +         */
  20.368 +        class DeferredAttrNode implements Infer.InferenceContext.FreeTypeListener {
  20.369 +
  20.370 +            /** underlying deferred type */
  20.371 +            DeferredType dt;
  20.372 +
  20.373 +            /** underlying target type information */
  20.374 +            ResultInfo resultInfo;
  20.375 +
  20.376 +            /** list of uninferred inference variables causing this node to be stuck */
  20.377 +            List<Type> stuckVars;
  20.378 +
  20.379 +            DeferredAttrNode(DeferredType dt, ResultInfo resultInfo, List<Type> stuckVars) {
  20.380 +                this.dt = dt;
  20.381 +                this.resultInfo = resultInfo;
  20.382 +                this.stuckVars = stuckVars;
  20.383 +                if (!stuckVars.isEmpty()) {
  20.384 +                    resultInfo.checkContext.inferenceContext().addFreeTypeListener(stuckVars, this);
  20.385 +                }
  20.386 +            }
  20.387 +
  20.388 +            @Override
  20.389 +            public void typesInferred(InferenceContext inferenceContext) {
  20.390 +                stuckVars = List.nil();
  20.391 +                resultInfo = resultInfo.dup(inferenceContext.asInstType(resultInfo.pt, types));
  20.392 +            }
  20.393 +
  20.394 +            /**
  20.395 +             * is this node stuck?
  20.396 +             */
  20.397 +            boolean isStuck() {
  20.398 +                return stuckVars.nonEmpty();
  20.399 +            }
  20.400 +
  20.401 +            /**
  20.402 +             * Process a deferred attribution node.
  20.403 +             * Invariant: a stuck node cannot be processed.
  20.404 +             */
  20.405 +            void process() {
  20.406 +                if (isStuck()) {
  20.407 +                    throw new IllegalStateException("Cannot process a stuck deferred node");
  20.408 +                }
  20.409 +                dt.check(resultInfo);
  20.410 +            }
  20.411 +        }
  20.412 +    }
  20.413 +
  20.414 +    /** an empty deferred attribution context - all methods throw exceptions */
  20.415 +    final DeferredAttrContext emptyDeferredAttrContext =
  20.416 +            new DeferredAttrContext(null, null, null, null) {
  20.417 +                @Override
  20.418 +                void addDeferredAttrNode(DeferredType dt, ResultInfo ri, List<Type> stuckVars) {
  20.419 +                    Assert.error("Empty deferred context!");
  20.420 +                }
  20.421 +                @Override
  20.422 +                void complete() {
  20.423 +                    Assert.error("Empty deferred context!");
  20.424 +                }
  20.425 +            };
  20.426 +
  20.427 +    /**
  20.428 +     * Map a list of types possibly containing one or more deferred types
  20.429 +     * into a list of ordinary types. Each deferred type D is mapped into a type T,
  20.430 +     * where T is computed by retrieving the type that has already been
  20.431 +     * computed for D during a previous deferred attribution round of the given kind.
  20.432 +     */
  20.433 +    class DeferredTypeMap extends Type.Mapping {
  20.434 +
  20.435 +        DeferredAttrContext deferredAttrContext;
  20.436 +
  20.437 +        protected DeferredTypeMap(AttrMode mode, Symbol msym, MethodResolutionPhase phase) {
  20.438 +            super(String.format("deferredTypeMap[%s]", mode));
  20.439 +            this.deferredAttrContext = new DeferredAttrContext(mode, msym, phase, infer.emptyContext);
  20.440 +        }
  20.441 +
  20.442 +        protected boolean validState(DeferredType dt) {
  20.443 +            return dt.mode != null &&
  20.444 +                    deferredAttrContext.mode.ordinal() <= dt.mode.ordinal();
  20.445 +        }
  20.446 +
  20.447 +        @Override
  20.448 +        public Type apply(Type t) {
  20.449 +            if (t.tag != DEFERRED) {
  20.450 +                return t.map(this);
  20.451 +            } else {
  20.452 +                DeferredType dt = (DeferredType)t;
  20.453 +                Assert.check(validState(dt));
  20.454 +                return typeOf(dt);
  20.455 +            }
  20.456 +        }
  20.457 +
  20.458 +        protected Type typeOf(DeferredType dt) {
  20.459 +            switch (deferredAttrContext.mode) {
  20.460 +                case CHECK:
  20.461 +                    return dt.tree.type == null ? Type.noType : dt.tree.type;
  20.462 +                case SPECULATIVE:
  20.463 +                    return dt.speculativeType(deferredAttrContext.msym, deferredAttrContext.phase);
  20.464 +            }
  20.465 +            Assert.error();
  20.466 +            return null;
  20.467 +        }
  20.468 +    }
  20.469 +
  20.470 +    /**
  20.471 +     * Specialized recovery deferred mapping.
  20.472 +     * Each deferred type D is mapped into a type T, where T is computed either by
  20.473 +     * (i) retrieving the type that has already been computed for D during a previous
  20.474 +     * attribution round (as before), or (ii) by synthesizing a new type R for D
  20.475 +     * (the latter step is useful in a recovery scenario).
  20.476 +     */
  20.477 +    public class RecoveryDeferredTypeMap extends DeferredTypeMap {
  20.478 +
  20.479 +        public RecoveryDeferredTypeMap(AttrMode mode, Symbol msym, MethodResolutionPhase phase) {
  20.480 +            super(mode, msym, phase);
  20.481 +        }
  20.482 +
  20.483 +        @Override
  20.484 +        protected Type typeOf(DeferredType dt) {
  20.485 +            Type owntype = super.typeOf(dt);
  20.486 +            return owntype.tag == NONE ?
  20.487 +                        recover(dt) : owntype;
  20.488 +        }
  20.489 +
  20.490 +        @Override
  20.491 +        protected boolean validState(DeferredType dt) {
  20.492 +            return true;
  20.493 +        }
  20.494 +
  20.495 +        /**
  20.496 +         * Synthesize a type for a deferred type that hasn't been previously
  20.497 +         * reduced to an ordinary type. Functional deferred types and conditionals
  20.498 +         * are mapped to themselves, in order to have a richer diagnostic
  20.499 +         * representation. Remaining deferred types are attributed using
  20.500 +         * a default expected type (j.l.Object).
  20.501 +         */
  20.502 +        private Type recover(DeferredType dt) {
  20.503 +            dt.check(attr.new RecoveryInfo(deferredAttrContext));
  20.504 +            switch (TreeInfo.skipParens(dt.tree).getTag()) {
  20.505 +                case LAMBDA:
  20.506 +                case REFERENCE:
  20.507 +                case CONDEXPR:
  20.508 +                    //propagate those deferred types to the
  20.509 +                    //diagnostic formatter
  20.510 +                    return dt;
  20.511 +                default:
  20.512 +                    return super.apply(dt);
  20.513 +            }
  20.514 +        }
  20.515 +    }
  20.516 +
  20.517 +    /**
  20.518 +     * Retrieves the list of inference variables that need to be inferred before
  20.519 +     * an AST node can be type-checked
  20.520 +     */
  20.521 +    @SuppressWarnings("fallthrough")
  20.522 +    List<Type> stuckVars(JCTree tree, ResultInfo resultInfo) {
  20.523 +        if (resultInfo.pt.tag == NONE || resultInfo.pt.isErroneous()) {
  20.524 +            return List.nil();
  20.525 +        } else {
  20.526 +            StuckChecker sc = new StuckChecker(resultInfo);
  20.527 +            sc.scan(tree);
  20.528 +            return List.from(sc.stuckVars);
  20.529 +        }
  20.530 +    }
  20.531 +
  20.532 +    /**
  20.533 +     * This visitor is used to check that structural expressions conform
  20.534 +     * to their target - this step is required as inference could end up
  20.535 +     * inferring types that make some of the nested expressions incompatible
  20.536 +     * with their corresponding instantiated target
  20.537 +     */
  20.538 +    class StuckChecker extends TreeScanner {
  20.539 +
  20.540 +        Type pt;
  20.541 +        Filter<JCTree> treeFilter;
  20.542 +        Infer.InferenceContext inferenceContext;
  20.543 +        Set<Type> stuckVars = new HashSet<Type>();
  20.544 +
  20.545 +        final Filter<JCTree> argsFilter = new Filter<JCTree>() {
  20.546 +            public boolean accepts(JCTree t) {
  20.547 +                switch (t.getTag()) {
  20.548 +                    case CONDEXPR:
  20.549 +                    case LAMBDA:
  20.550 +                    case PARENS:
  20.551 +                    case REFERENCE:
  20.552 +                        return true;
  20.553 +                    default:
  20.554 +                        return false;
  20.555 +                }
  20.556 +            }
  20.557 +        };
  20.558 +
  20.559 +        final Filter<JCTree> lambdaBodyFilter = new Filter<JCTree>() {
  20.560 +            public boolean accepts(JCTree t) {
  20.561 +                switch (t.getTag()) {
  20.562 +                    case BLOCK: case CASE: case CATCH: case DOLOOP:
  20.563 +                    case FOREACHLOOP: case FORLOOP: case RETURN:
  20.564 +                    case SYNCHRONIZED: case SWITCH: case TRY: case WHILELOOP:
  20.565 +                        return true;
  20.566 +                    default:
  20.567 +                        return false;
  20.568 +                }
  20.569 +            }
  20.570 +        };
  20.571 +
  20.572 +        StuckChecker(ResultInfo resultInfo) {
  20.573 +            this.pt = resultInfo.pt;
  20.574 +            this.inferenceContext = resultInfo.checkContext.inferenceContext();
  20.575 +            this.treeFilter = argsFilter;
  20.576 +        }
  20.577 +
  20.578 +        @Override
  20.579 +        public void scan(JCTree tree) {
  20.580 +            if (tree != null && treeFilter.accepts(tree)) {
  20.581 +                super.scan(tree);
  20.582 +            }
  20.583 +        }
  20.584 +
  20.585 +        @Override
  20.586 +        public void visitLambda(JCLambda tree) {
  20.587 +            Type prevPt = pt;
  20.588 +            Filter<JCTree> prevFilter = treeFilter;
  20.589 +            try {
  20.590 +                if (inferenceContext.inferenceVars().contains(pt)) {
  20.591 +                    stuckVars.add(pt);
  20.592 +                }
  20.593 +                if (!types.isFunctionalInterface(pt.tsym)) {
  20.594 +                    return;
  20.595 +                }
  20.596 +                Type descType = types.findDescriptorType(pt);
  20.597 +                List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
  20.598 +                if (!TreeInfo.isExplicitLambda(tree) &&
  20.599 +                        freeArgVars.nonEmpty()) {
  20.600 +                    stuckVars.addAll(freeArgVars);
  20.601 +                }
  20.602 +                pt = descType.getReturnType();
  20.603 +                if (tree.getBodyKind() == JCTree.JCLambda.BodyKind.EXPRESSION) {
  20.604 +                    scan(tree.getBody());
  20.605 +                } else {
  20.606 +                    treeFilter = lambdaBodyFilter;
  20.607 +                    super.visitLambda(tree);
  20.608 +                }
  20.609 +            } finally {
  20.610 +                pt = prevPt;
  20.611 +                treeFilter = prevFilter;
  20.612 +            }
  20.613 +        }
  20.614 +
  20.615 +        @Override
  20.616 +        public void visitReference(JCMemberReference tree) {
  20.617 +            scan(tree.expr);
  20.618 +            if (inferenceContext.inferenceVars().contains(pt)) {
  20.619 +                stuckVars.add(pt);
  20.620 +                return;
  20.621 +            }
  20.622 +            if (!types.isFunctionalInterface(pt.tsym)) {
  20.623 +                return;
  20.624 +            }
  20.625 +            Type descType = types.findDescriptorType(pt);
  20.626 +            List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
  20.627 +            stuckVars.addAll(freeArgVars);
  20.628 +        }
  20.629 +
  20.630 +        @Override
  20.631 +        public void visitReturn(JCReturn tree) {
  20.632 +            Filter<JCTree> prevFilter = treeFilter;
  20.633 +            try {
  20.634 +                treeFilter = argsFilter;
  20.635 +                if (tree.expr != null) {
  20.636 +                    scan(tree.expr);
  20.637 +                }
  20.638 +            } finally {
  20.639 +                treeFilter = prevFilter;
  20.640 +            }
  20.641 +        }
  20.642 +    }
  20.643 +}

    21.1 --- a/src/share/classes/com/sun/tools/javac/comp/Flow.java	Thu Oct 11 09:50:52 2012 -0700
    21.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Flow.java	Thu Oct 11 17:00:54 2012 -0700
    21.3 @@ -50,8 +50,8 @@
    21.4   *  (see AssignAnalyzer) ensures that each variable is assigned when used.  Definite
    21.5   *  unassignment analysis (see AssignAnalyzer) in ensures that no final variable
    21.6   *  is assigned more than once. Finally, local variable capture analysis (see CaptureAnalyzer)
    21.7 - *  determines that local variables accessed within the scope of an inner class are
    21.8 - *  either final or effectively-final.
    21.9 + *  determines that local variables accessed within the scope of an inner class/lambda
   21.10 + *  are either final or effectively-final.
   21.11   *
   21.12   *  <p>The JLS has a number of problems in the
   21.13   *  specification of these flow analysis problems. This implementation
   21.14 @@ -211,6 +211,29 @@
   21.15          new CaptureAnalyzer().analyzeTree(env, make);
   21.16      }
   21.17  
   21.18 +    public void analyzeLambda(Env<AttrContext> env, JCLambda that, TreeMaker make, boolean speculative) {
   21.19 +        java.util.Queue<JCDiagnostic> prevDeferredDiagnostics = log.deferredDiagnostics;
   21.20 +        Filter<JCDiagnostic> prevDeferDiagsFilter = log.deferredDiagFilter;
   21.21 +        //we need to disable diagnostics temporarily; the problem is that if
   21.22 +        //a lambda expression contains e.g. an unreachable statement, an error
   21.23 +        //message will be reported and will cause compilation to skip the flow analyis
   21.24 +        //step - if we suppress diagnostics, we won't stop at Attr for flow-analysis
   21.25 +        //related errors, which will allow for more errors to be detected
   21.26 +        if (!speculative) {
   21.27 +            log.deferAll();
   21.28 +            log.deferredDiagnostics = ListBuffer.lb();
   21.29 +        }
   21.30 +        try {
   21.31 +            new AliveAnalyzer().analyzeTree(env, that, make);
   21.32 +            new FlowAnalyzer().analyzeTree(env, that, make);
   21.33 +        } finally {
   21.34 +            if (!speculative) {
   21.35 +                log.deferredDiagFilter = prevDeferDiagsFilter;
   21.36 +                log.deferredDiagnostics = prevDeferredDiagnostics;
   21.37 +            }
   21.38 +        }
   21.39 +    }
   21.40 +
   21.41      /**
   21.42       * Definite assignment scan mode
   21.43       */
   21.44 @@ -659,6 +682,27 @@
   21.45              }
   21.46          }
   21.47  
   21.48 +        @Override
   21.49 +        public void visitLambda(JCLambda tree) {
   21.50 +            if (tree.type != null &&
   21.51 +                    tree.type.isErroneous()) {
   21.52 +                return;
   21.53 +            }
   21.54 +
   21.55 +            ListBuffer<PendingExit> prevPending = pendingExits;
   21.56 +            boolean prevAlive = alive;
   21.57 +            try {
   21.58 +                pendingExits = ListBuffer.lb();
   21.59 +                alive = true;
   21.60 +                scanStat(tree.body);
   21.61 +                tree.canCompleteNormally = alive;
   21.62 +            }
   21.63 +            finally {
   21.64 +                pendingExits = prevPending;
   21.65 +                alive = prevAlive;
   21.66 +            }
   21.67 +        }
   21.68 +
   21.69          public void visitTopLevel(JCCompilationUnit tree) {
   21.70              // Do nothing for TopLevel since each class is visited individually
   21.71          }
   21.72 @@ -670,6 +714,9 @@
   21.73          /** Perform definite assignment/unassignment analysis on a tree.
   21.74           */
   21.75          public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
   21.76 +            analyzeTree(env, env.tree, make);
   21.77 +        }
   21.78 +        public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
   21.79              try {
   21.80                  attrEnv = env;
   21.81                  Flow.this.make = make;
   21.82 @@ -1185,6 +1232,29 @@
   21.83              }
   21.84          }
   21.85  
   21.86 +        @Override
   21.87 +        public void visitLambda(JCLambda tree) {
   21.88 +            if (tree.type != null &&
   21.89 +                    tree.type.isErroneous()) {
   21.90 +                return;
   21.91 +            }
   21.92 +            List<Type> prevCaught = caught;
   21.93 +            List<Type> prevThrown = thrown;
   21.94 +            ListBuffer<FlowPendingExit> prevPending = pendingExits;
   21.95 +            try {
   21.96 +                pendingExits = ListBuffer.lb();
   21.97 +                caught = List.of(syms.throwableType); //inhibit exception checking
   21.98 +                thrown = List.nil();
   21.99 +                scan(tree.body);
  21.100 +                tree.inferredThrownTypes = thrown;
  21.101 +            }
  21.102 +            finally {
  21.103 +                pendingExits = prevPending;
  21.104 +                caught = prevCaught;
  21.105 +                thrown = prevThrown;
  21.106 +            }
  21.107 +        }
  21.108 +
  21.109          public void visitTopLevel(JCCompilationUnit tree) {
  21.110              // Do nothing for TopLevel since each class is visited individually
  21.111          }
  21.112 @@ -1267,6 +1337,10 @@
  21.113           */
  21.114          int nextadr;
  21.115  
  21.116 +        /** The first variable sequence number in a block that can return.
  21.117 +         */
  21.118 +        int returnadr;
  21.119 +
  21.120          /** The list of unreferenced automatic resources.
  21.121           */
  21.122          Scope unrefdResources;
  21.123 @@ -1296,8 +1370,8 @@
  21.124  
  21.125          @Override
  21.126          void markDead() {
  21.127 -            inits.inclRange(firstadr, nextadr);
  21.128 -            uninits.inclRange(firstadr, nextadr);
  21.129 +            inits.inclRange(returnadr, nextadr);
  21.130 +            uninits.inclRange(returnadr, nextadr);
  21.131          }
  21.132  
  21.133          /*-------------- Processing variables ----------------------*/
  21.134 @@ -1318,11 +1392,7 @@
  21.135           *  index into the vars array.
  21.136           */
  21.137          void newVar(VarSymbol sym) {
  21.138 -            if (nextadr == vars.length) {
  21.139 -                VarSymbol[] newvars = new VarSymbol[nextadr * 2];
  21.140 -                System.arraycopy(vars, 0, newvars, 0, nextadr);
  21.141 -                vars = newvars;
  21.142 -            }
  21.143 +            vars = ArrayUtils.ensureCapacity(vars, nextadr);
  21.144              if ((sym.flags() & FINAL) == 0) {
  21.145                  sym.flags_field |= EFFECTIVELY_FINAL;
  21.146              }
  21.147 @@ -1556,6 +1626,7 @@
  21.148              Bits uninitsPrev = uninits.dup();
  21.149              int nextadrPrev = nextadr;
  21.150              int firstadrPrev = firstadr;
  21.151 +            int returnadrPrev = returnadr;
  21.152              Lint lintPrev = lint;
  21.153  
  21.154              lint = lint.augment(tree.sym.annotations);
  21.155 @@ -1600,6 +1671,7 @@
  21.156                  uninits = uninitsPrev;
  21.157                  nextadr = nextadrPrev;
  21.158                  firstadr = firstadrPrev;
  21.159 +                returnadr = returnadrPrev;
  21.160                  lint = lintPrev;
  21.161              }
  21.162          }
  21.163 @@ -1984,6 +2056,35 @@
  21.164              scan(tree.def);
  21.165          }
  21.166  
  21.167 +        @Override
  21.168 +        public void visitLambda(JCLambda tree) {
  21.169 +            Bits prevUninits = uninits;
  21.170 +            Bits prevInits = inits;
  21.171 +            int returnadrPrev = returnadr;
  21.172 +            ListBuffer<AssignPendingExit> prevPending = pendingExits;
  21.173 +            try {
  21.174 +                returnadr = nextadr;
  21.175 +                pendingExits = new ListBuffer<AssignPendingExit>();
  21.176 +                for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
  21.177 +                    JCVariableDecl def = l.head;
  21.178 +                    scan(def);
  21.179 +                    inits.incl(def.sym.adr);
  21.180 +                    uninits.excl(def.sym.adr);
  21.181 +                }
  21.182 +                if (tree.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
  21.183 +                    scanExpr(tree.body);
  21.184 +                } else {
  21.185 +                    scan(tree.body);
  21.186 +                }
  21.187 +            }
  21.188 +            finally {
  21.189 +                returnadr = returnadrPrev;
  21.190 +                uninits = prevUninits;
  21.191 +                inits = prevInits;
  21.192 +                pendingExits = prevPending;
  21.193 +            }
  21.194 +        }
  21.195 +
  21.196          public void visitNewArray(JCNewArray tree) {
  21.197              scanExprs(tree.dims);
  21.198              scanExprs(tree.elems);