Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/.hgtags	Mon May 19 22:00:11 2014 -0700
     1.2 +++ b/.hgtags	Thu May 29 13:46:36 2014 -0700
     1.3 @@ -245,7 +245,9 @@
     1.4  afe63d41c699e0e2ee910ef20c41b60603c852a1 jdk8-b121
     1.5  232b9cf6303aaf451c7000c5f93dfea842e9e9ae jdk8-b122
     1.6  a345cf28faca8cc49a28241a0a197fd520d25beb jdk8-b123
     1.7 +d5aab8300d3b51e8043ab5fe5832ef6c6cbb5552 jdk8u20-b00
     1.8  436176151e85455e74cd1441a2ba96e791c56785 jdk8-b124
     1.9 +79dc4b992c0a385c1364592801781b747b85c6ca jdk8u20-b01
    1.10  436176151e85455e74cd1441a2ba96e791c56785 jdk8-b125
    1.11  ba24b63043626003929927f091e8b84190f39261 jdk8-b126
    1.12  bb69217ed81202b1a490dc7150dc7cd073689341 jdk8-b127
    1.13 @@ -277,4 +279,21 @@
    1.14  7803caf52e4b12f11e552565f55ef65aeb2be6a5 jdk8u11-b07
    1.15  a47aa3203c0210def786ab5ee685e97d07e8bf77 jdk8u11-b08
    1.16  e973a591a2182c0bdbdd9545ab13f83325acf1e6 jdk8u11-b09
    1.17 +51cade4632608a6c0b8da33f420bd546aecf6faf jdk8u11-b10
    1.18 +26b33a6ea08810853af37e81c9b435465b289c98 jdk8u20-b02
    1.19 +a07271bca831cf1bab35a2ffbcebd8e060b2734b jdk8u20-b03
    1.20 +613c1d9930c9f650e3fc6926215931a85b679c66 jdk8u20-b04
    1.21 +27c08b9195d17f8e13cb90f6a7c9b6877062464f jdk8u20-b05
    1.22 +9d81ae1c417a4748f58921c1f8def7f3c401cecd jdk8-b130
    1.23 +196ab3dcbd28fac1578590684a337f1c7cf505c9 jdk8-b131
    1.24 +c8a87a58eb3efdd64055566b502c9d4a72ca0996 jdk8-b132
    1.25 +c6d0108aca9f8f45b9cddeb6e483d464509e0127 jdk8u20-b06
    1.26 +1a57c569cb811a897691e42049eca33da8f8d761 jdk8u20-b07
    1.27 +0f821eb7e92b242c878dca68ef63f9626643ee8f jdk8u20-b08
    1.28 +aa0cb3af23d376e012a142b0531c4f42032fdacf jdk8u20-b09
    1.29 +a0d9c18a1041c4217db9cda1817f0e348f1be885 jdk8u20-b10
    1.30 +7ad480b982bf95b8a7290c8769b2698f6aacaf6b jdk8u20-b11
    1.31 +e101a12a45a777268a2e729803499a7514255e5b jdk8u20-b12
    1.32 +b5c2375893e2bca1883e5571bd911b6f0b533bf4 jdk8u20-b13
    1.33 +5d39c29950f4d65e737f99e468427ae6454fa586 jdk8u20-b14
    1.34  f491f1581f196950c2cb858508dd06601968c417 jdk8u25-b00

     2.1 --- a/src/share/classes/com/sun/tools/classfile/Attribute.java	Mon May 19 22:00:11 2014 -0700
     2.2 +++ b/src/share/classes/com/sun/tools/classfile/Attribute.java	Thu May 29 13:46:36 2014 -0700
     2.3 @@ -71,10 +71,6 @@
     2.4              // defer init of standardAttributeClasses until after options set up
     2.5          }
     2.6  
     2.7 -        public void setCompat(boolean compat) {
     2.8 -            this.compat = compat;
     2.9 -        }
    2.10 -
    2.11          public Attribute createAttribute(ClassReader cr, int name_index, byte[] data)
    2.12                  throws IOException {
    2.13              if (standardAttributes == null) {
    2.14 @@ -109,9 +105,10 @@
    2.15          protected void init() {
    2.16              standardAttributes = new HashMap<String,Class<? extends Attribute>>();
    2.17              standardAttributes.put(AnnotationDefault, AnnotationDefault_attribute.class);
    2.18 -            standardAttributes.put(BootstrapMethods, BootstrapMethods_attribute.class);
    2.19 +            standardAttributes.put(BootstrapMethods,  BootstrapMethods_attribute.class);
    2.20              standardAttributes.put(CharacterRangeTable, CharacterRangeTable_attribute.class);
    2.21              standardAttributes.put(Code,              Code_attribute.class);
    2.22 +            standardAttributes.put(CompilationID,     CompilationID_attribute.class);
    2.23              standardAttributes.put(ConstantValue,     ConstantValue_attribute.class);
    2.24              standardAttributes.put(Deprecated,        Deprecated_attribute.class);
    2.25              standardAttributes.put(EnclosingMethod,   EnclosingMethod_attribute.class);
    2.26 @@ -120,29 +117,23 @@
    2.27              standardAttributes.put(LineNumberTable,   LineNumberTable_attribute.class);
    2.28              standardAttributes.put(LocalVariableTable, LocalVariableTable_attribute.class);
    2.29              standardAttributes.put(LocalVariableTypeTable, LocalVariableTypeTable_attribute.class);
    2.30 -
    2.31 -            if (!compat) { // old javap does not recognize recent attributes
    2.32 -                standardAttributes.put(MethodParameters, MethodParameters_attribute.class);
    2.33 -                standardAttributes.put(CompilationID, CompilationID_attribute.class);
    2.34 -                standardAttributes.put(RuntimeInvisibleAnnotations, RuntimeInvisibleAnnotations_attribute.class);
    2.35 -                standardAttributes.put(RuntimeInvisibleParameterAnnotations, RuntimeInvisibleParameterAnnotations_attribute.class);
    2.36 -                standardAttributes.put(RuntimeVisibleAnnotations, RuntimeVisibleAnnotations_attribute.class);
    2.37 -                standardAttributes.put(RuntimeVisibleParameterAnnotations, RuntimeVisibleParameterAnnotations_attribute.class);
    2.38 -                standardAttributes.put(RuntimeVisibleTypeAnnotations, RuntimeVisibleTypeAnnotations_attribute.class);
    2.39 -                standardAttributes.put(RuntimeInvisibleTypeAnnotations, RuntimeInvisibleTypeAnnotations_attribute.class);
    2.40 -                standardAttributes.put(Signature,     Signature_attribute.class);
    2.41 -                standardAttributes.put(SourceID, SourceID_attribute.class);
    2.42 -            }
    2.43 -
    2.44 +            standardAttributes.put(MethodParameters,  MethodParameters_attribute.class);
    2.45 +            standardAttributes.put(RuntimeInvisibleAnnotations, RuntimeInvisibleAnnotations_attribute.class);
    2.46 +            standardAttributes.put(RuntimeInvisibleParameterAnnotations, RuntimeInvisibleParameterAnnotations_attribute.class);
    2.47 +            standardAttributes.put(RuntimeVisibleAnnotations, RuntimeVisibleAnnotations_attribute.class);
    2.48 +            standardAttributes.put(RuntimeVisibleParameterAnnotations, RuntimeVisibleParameterAnnotations_attribute.class);
    2.49 +            standardAttributes.put(RuntimeVisibleTypeAnnotations, RuntimeVisibleTypeAnnotations_attribute.class);
    2.50 +            standardAttributes.put(RuntimeInvisibleTypeAnnotations, RuntimeInvisibleTypeAnnotations_attribute.class);
    2.51 +            standardAttributes.put(Signature,         Signature_attribute.class);
    2.52              standardAttributes.put(SourceDebugExtension, SourceDebugExtension_attribute.class);
    2.53              standardAttributes.put(SourceFile,        SourceFile_attribute.class);
    2.54 +            standardAttributes.put(SourceID,          SourceID_attribute.class);
    2.55              standardAttributes.put(StackMap,          StackMap_attribute.class);
    2.56              standardAttributes.put(StackMapTable,     StackMapTable_attribute.class);
    2.57              standardAttributes.put(Synthetic,         Synthetic_attribute.class);
    2.58          }
    2.59  
    2.60          private Map<String,Class<? extends Attribute>> standardAttributes;
    2.61 -        private boolean compat; // don't support recent attrs in compatibility mode
    2.62      }
    2.63  
    2.64      public static Attribute read(ClassReader cr) throws IOException {

     3.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/resources/standard_ja.properties	Mon May 19 22:00:11 2014 -0700
     3.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/resources/standard_ja.properties	Thu May 29 13:46:36 2014 -0700
     3.3 @@ -29,7 +29,7 @@
     3.4  doclet.Href_Enum_Title={0}\u5185\u306E\u5217\u6319\u578B
     3.5  doclet.Href_Type_Param_Title={0}\u5185\u306E\u578B\u30D1\u30E9\u30E1\u30FC\u30BF
     3.6  doclet.Href_Class_Or_Interface_Title={0}\u5185\u306E\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9
     3.7 -doclet.Summary=\u6982\u8981:
     3.8 +doclet.Summary=\u30B5\u30DE\u30EA\u30FC:
     3.9  doclet.Detail=\u8A73\u7D30:
    3.10  doclet.navNested=\u30CD\u30B9\u30C8
    3.11  doclet.navAnnotationTypeOptionalMember=\u30AA\u30D7\u30B7\u30E7\u30F3
    3.12 @@ -117,18 +117,18 @@
    3.13  doclet.Window_Source_title=\u30BD\u30FC\u30B9\u30FB\u30B3\u30FC\u30C9
    3.14  doclet.Window_Help_title=API\u30D8\u30EB\u30D7
    3.15  doclet.Help_line_1=API\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u306E\u69CB\u6210
    3.16 -doclet.Help_line_2=\u3053\u306EAPI(Application Programming Interface)\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u306B\u306F\u3001\u6B21\u306B\u8AAC\u660E\u3059\u308B\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u30FB\u30D0\u30FC\u306B\u3042\u308B\u9805\u76EE\u306B\u5BFE\u5FDC\u3059\u308B\u30DA\u30FC\u30B8\u304C\u542B\u307E\u308C\u307E\u3059\u3002
    3.17 -doclet.Help_line_3={0}\u30DA\u30FC\u30B8\u306FAPI\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u306E\u30D5\u30ED\u30F3\u30C8\u30FB\u30DA\u30FC\u30B8\u3067\u3001\u5404\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u6982\u8981\u3092\u542B\u3080\u5168\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u30EA\u30B9\u30C8\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u4E00\u9023\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u6982\u8981\u8AAC\u660E\u3082\u8868\u793A\u3055\u308C\u307E\u3059\u3002
    3.18 -doclet.Help_line_4=\u5404\u30D1\u30C3\u30B1\u30FC\u30B8\u306B\u306F\u3001\u305D\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u30AF\u30E9\u30B9\u304A\u3088\u3073\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u30EA\u30B9\u30C8\u3068\u3001\u305D\u308C\u305E\u308C\u306E\u6982\u8981\u3092\u542B\u3080\u30DA\u30FC\u30B8\u304C\u3042\u308A\u307E\u3059\u3002\u3053\u306E\u30DA\u30FC\u30B8\u306F6\u3064\u306E\u30AB\u30C6\u30B4\u30EA\u3067\u69CB\u6210\u3055\u308C\u307E\u3059\u3002
    3.19 +doclet.Help_line_2=\u3053\u306EAPI (Application Programming Interface)\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u306B\u306F\u3001\u6B21\u306B\u8AAC\u660E\u3059\u308B\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u30FB\u30D0\u30FC\u306B\u3042\u308B\u9805\u76EE\u306B\u5BFE\u5FDC\u3059\u308B\u30DA\u30FC\u30B8\u304C\u542B\u307E\u308C\u307E\u3059\u3002
    3.20 +doclet.Help_line_3={0}\u30DA\u30FC\u30B8\u306FAPI\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u306E\u30D5\u30ED\u30F3\u30C8\u30FB\u30DA\u30FC\u30B8\u3067\u3001\u5404\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u30B5\u30DE\u30EA\u30FC\u3092\u542B\u3080\u5168\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u30EA\u30B9\u30C8\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u4E00\u9023\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u5168\u4F53\u7684\u306A\u8AAC\u660E\u3082\u8868\u793A\u3055\u308C\u307E\u3059\u3002
    3.21 +doclet.Help_line_4=\u5404\u30D1\u30C3\u30B1\u30FC\u30B8\u306B\u306F\u3001\u305D\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u30AF\u30E9\u30B9\u304A\u3088\u3073\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u30EA\u30B9\u30C8\u3068\u3001\u305D\u308C\u305E\u308C\u306E\u30B5\u30DE\u30EA\u30FC\u3092\u542B\u3080\u30DA\u30FC\u30B8\u304C\u3042\u308A\u307E\u3059\u3002\u3053\u306E\u30DA\u30FC\u30B8\u306F6\u3064\u306E\u30AB\u30C6\u30B4\u30EA\u3067\u69CB\u6210\u3055\u308C\u307E\u3059\u3002
    3.22  doclet.Help_line_5=\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9
    3.23 -doclet.Help_line_6=\u5404\u30AF\u30E9\u30B9\u3001\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3001\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30AF\u30E9\u30B9\u304A\u3088\u3073\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306B\u306F\u500B\u5225\u306E\u30DA\u30FC\u30B8\u304C\u3042\u308A\u307E\u3059\u3002\u5404\u30DA\u30FC\u30B8\u306B\u306F\u6B21\u306E\u3088\u3046\u306B\u3001\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u8AAC\u660E\u3068\u3001\u6982\u8981\u8868\u304A\u3088\u3073\u30E1\u30F3\u30D0\u30FC\u306E\u8A73\u7D30\u8AAC\u660E\u304C\u542B\u307E\u308C\u307E\u3059\u3002
    3.24 +doclet.Help_line_6=\u5404\u30AF\u30E9\u30B9\u3001\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3001\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30AF\u30E9\u30B9\u304A\u3088\u3073\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306B\u306F\u500B\u5225\u306E\u30DA\u30FC\u30B8\u304C\u3042\u308A\u307E\u3059\u3002\u5404\u30DA\u30FC\u30B8\u306B\u306F\u6B21\u306E\u3088\u3046\u306B\u3001\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u8AAC\u660E\u3068\u3001\u30B5\u30DE\u30EA\u30FC\u8868\u304A\u3088\u3073\u30E1\u30F3\u30D0\u30FC\u306E\u8A73\u7D30\u8AAC\u660E\u304C\u542B\u307E\u308C\u307E\u3059\u3002
    3.25  doclet.Help_line_7=\u30AF\u30E9\u30B9\u968E\u5C64\u8868\u793A
    3.26  doclet.Help_line_8=\u76F4\u7CFB\u306E\u30B5\u30D6\u30AF\u30E9\u30B9
    3.27  doclet.Help_line_9=\u65E2\u77E5\u306E\u30B5\u30D6\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u30EA\u30B9\u30C8
    3.28  doclet.Help_line_10=\u65E2\u77E5\u306E\u5B9F\u88C5\u30AF\u30E9\u30B9\u306E\u30EA\u30B9\u30C8
    3.29  doclet.Help_line_11=\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u5BA3\u8A00
    3.30  doclet.Help_line_12=\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u8AAC\u660E
    3.31 -doclet.Help_line_13=\u5404\u6982\u8981\u30A8\u30F3\u30C8\u30EA\u306B\u306F\u3001\u305D\u306E\u9805\u76EE\u306E\u8A73\u7D30\u306A\u8AAC\u660E\u306E\u4E2D\u304B\u30891\u884C\u76EE\u306E\u6587\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u8A73\u7D30\u306A\u8AAC\u660E\u306F\u30BD\u30FC\u30B9\u30FB\u30B3\u30FC\u30C9\u306B\u73FE\u308C\u308B\u9806\u306B\u4E26\u3079\u3089\u308C\u307E\u3059\u304C\u3001\u6982\u8981\u30A8\u30F3\u30C8\u30EA\u306F\u30A2\u30EB\u30D5\u30A1\u30D9\u30C3\u30C8\u9806\u306B\u4E26\u3079\u3089\u308C\u307E\u3059\u3002\u3053\u308C\u306B\u3088\u3063\u3066\u3001\u30D7\u30ED\u30B0\u30E9\u30DE\u304C\u8A2D\u5B9A\u3057\u305F\u8AD6\u7406\u7684\u306A\u30B0\u30EB\u30FC\u30D7\u5206\u3051\u304C\u4FDD\u6301\u3055\u308C\u307E\u3059\u3002
    3.32 +doclet.Help_line_13=\u5404\u30B5\u30DE\u30EA\u30FC\u30FB\u30A8\u30F3\u30C8\u30EA\u306B\u306F\u3001\u305D\u306E\u9805\u76EE\u306E\u8A73\u7D30\u8AAC\u660E\u306E\u4E2D\u304B\u30891\u884C\u76EE\u306E\u6587\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u30B5\u30DE\u30EA\u30FC\u30FB\u30A8\u30F3\u30C8\u30EA\u306F\u30A2\u30EB\u30D5\u30A1\u30D9\u30C3\u30C8\u9806\u3067\u3059\u304C\u3001\u8A73\u7D30\u8AAC\u660E\u306F\u30BD\u30FC\u30B9\u30FB\u30B3\u30FC\u30C9\u306B\u73FE\u308C\u308B\u9806\u306B\u306A\u3063\u3066\u3044\u307E\u3059\u3002\u3053\u308C\u306B\u3088\u3063\u3066\u3001\u30D7\u30ED\u30B0\u30E9\u30DE\u304C\u8A2D\u5B9A\u3057\u305F\u8AD6\u7406\u7684\u306A\u30B0\u30EB\u30FC\u30D7\u5206\u3051\u304C\u4FDD\u6301\u3055\u308C\u307E\u3059\u3002
    3.33  doclet.Help_line_14=\u4F7F\u7528
    3.34  doclet.Help_line_15=\u5404\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u5316\u3055\u308C\u305F\u30D1\u30C3\u30B1\u30FC\u30B8\u3001\u30AF\u30E9\u30B9\u304A\u3088\u3073\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306B\u306F\u305D\u308C\u305E\u308C\u300C\u4F7F\u7528\u300D\u30DA\u30FC\u30B8\u304C\u3042\u308A\u307E\u3059\u3002\u3053\u306E\u30DA\u30FC\u30B8\u306B\u306F\u3001\u3069\u306E\u3088\u3046\u306A\u30D1\u30C3\u30B1\u30FC\u30B8\u3001\u30AF\u30E9\u30B9\u3001\u30E1\u30BD\u30C3\u30C9\u3001\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u304A\u3088\u3073\u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u3001\u7279\u5B9A\u306E\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u4E00\u90E8\u3092\u4F7F\u7528\u3057\u3066\u3044\u308B\u304B\u304C\u8A18\u8FF0\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u305F\u3068\u3048\u3070\u3001\u30AF\u30E9\u30B9A\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9A\u306E\u5834\u5408\u3001\u305D\u306E\u300C\u4F7F\u7528\u300D\u30DA\u30FC\u30B8\u306B\u306F\u3001A\u306E\u30B5\u30D6\u30AF\u30E9\u30B9\u3001A\u3068\u3057\u3066\u5BA3\u8A00\u3055\u308C\u308B\u30D5\u30A3\u30FC\u30EB\u30C9\u3001A\u3092\u8FD4\u3059\u30E1\u30BD\u30C3\u30C9\u3068\u3001\u578BA\u3092\u6301\u3064\u30E1\u30BD\u30C3\u30C9\u304A\u3088\u3073\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u304C\u542B\u307E\u308C\u307E\u3059\u3002\u3053\u306E\u30DA\u30FC\u30B8\u306B\u30A2\u30AF\u30BB\u30B9\u3059\u308B\u306B\u306F\u3001\u307E\u305A\u305D\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u3001\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306B\u79FB\u52D5\u3057\u3001\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u30FB\u30D0\u30FC\u306E\u300C\u4F7F\u7528\u300D\u30EA\u30F3\u30AF\u3092\u30AF\u30EA\u30C3\u30AF\u3057\u3066\u304F\u3060\u3055\u3044\u3002
    3.35  doclet.Help_line_16=\u968E\u5C64\u30C4\u30EA\u30FC(\u30AF\u30E9\u30B9\u968E\u5C64)

     4.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets_ja.properties	Mon May 19 22:00:11 2014 -0700
     4.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets_ja.properties	Thu May 29 13:46:36 2014 -0700
     4.3 @@ -66,22 +66,22 @@
     4.4  doclet.malformed_html_link_tag=<a> \u30BF\u30B0\u306E\u5F62\u5F0F\u304C\u4E0D\u6B63:\n"{0}"
     4.5  doclet.tag_misuse={0}\u30BF\u30B0\u306F{1}\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u5185\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u4F7F\u7528\u3067\u304D\u308B\u306E\u306F\u6B21\u306E\u30BF\u30A4\u30D7\u306E\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u5185\u306E\u307F\u3067\u3059: {2}\u3002
     4.6  doclet.javafx_tag_misuse=\u30BF\u30B0@propertyGetter\u3001@propertySetter\u304A\u3088\u3073@propertyDescription\u306F\u3001JavaFX\u306E\u30D7\u30ED\u30D1\u30C6\u30A3getter\u3068setter\u306E\u307F\u3067\u4F7F\u7528\u3067\u304D\u307E\u3059\u3002
     4.7 -doclet.Package_Summary=\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u6982\u8981
     4.8 +doclet.Package_Summary=\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u30B5\u30DE\u30EA\u30FC
     4.9  doclet.Profile_Summary=\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u30FB\u30B5\u30DE\u30EA\u30FC
    4.10 -doclet.Interface_Summary=\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u6982\u8981
    4.11 -doclet.Annotation_Types_Summary=\u6CE8\u91C8\u578B\u306E\u6982\u8981
    4.12 -doclet.Enum_Summary=\u5217\u6319\u578B\u306E\u6982\u8981
    4.13 -doclet.Exception_Summary=\u4F8B\u5916\u306E\u6982\u8981
    4.14 -doclet.Error_Summary=\u30A8\u30E9\u30FC\u306E\u6982\u8981
    4.15 -doclet.Class_Summary=\u30AF\u30E9\u30B9\u306E\u6982\u8981
    4.16 -doclet.Nested_Class_Summary=\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30AF\u30E9\u30B9\u306E\u6982\u8981
    4.17 -doclet.Annotation_Type_Optional_Member_Summary=\u4EFB\u610F\u8981\u7D20\u306E\u6982\u8981
    4.18 -doclet.Annotation_Type_Required_Member_Summary=\u5FC5\u9808\u8981\u7D20\u306E\u6982\u8981
    4.19 -doclet.Field_Summary=\u30D5\u30A3\u30FC\u30EB\u30C9\u306E\u6982\u8981
    4.20 -doclet.Property_Summary=\u30D7\u30ED\u30D1\u30C6\u30A3\u306E\u6982\u8981
    4.21 -doclet.Enum_Constant_Summary=\u5217\u6319\u578B\u5B9A\u6570\u306E\u6982\u8981
    4.22 -doclet.Constructor_Summary=\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u6982\u8981
    4.23 -doclet.Method_Summary=\u30E1\u30BD\u30C3\u30C9\u306E\u6982\u8981
    4.24 +doclet.Interface_Summary=\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306E\u30B5\u30DE\u30EA\u30FC
    4.25 +doclet.Annotation_Types_Summary=\u6CE8\u91C8\u578B\u306E\u30B5\u30DE\u30EA\u30FC
    4.26 +doclet.Enum_Summary=\u5217\u6319\u578B\u306E\u30B5\u30DE\u30EA\u30FC
    4.27 +doclet.Exception_Summary=\u4F8B\u5916\u306E\u30B5\u30DE\u30EA\u30FC
    4.28 +doclet.Error_Summary=\u30A8\u30E9\u30FC\u306E\u30B5\u30DE\u30EA\u30FC
    4.29 +doclet.Class_Summary=\u30AF\u30E9\u30B9\u306E\u30B5\u30DE\u30EA\u30FC
    4.30 +doclet.Nested_Class_Summary=\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30AF\u30E9\u30B9\u306E\u30B5\u30DE\u30EA\u30FC
    4.31 +doclet.Annotation_Type_Optional_Member_Summary=\u4EFB\u610F\u8981\u7D20\u306E\u30B5\u30DE\u30EA\u30FC
    4.32 +doclet.Annotation_Type_Required_Member_Summary=\u5FC5\u9808\u8981\u7D20\u306E\u30B5\u30DE\u30EA\u30FC
    4.33 +doclet.Field_Summary=\u30D5\u30A3\u30FC\u30EB\u30C9\u306E\u30B5\u30DE\u30EA\u30FC
    4.34 +doclet.Property_Summary=\u30D7\u30ED\u30D1\u30C6\u30A3\u306E\u30B5\u30DE\u30EA\u30FC
    4.35 +doclet.Enum_Constant_Summary=\u5217\u6319\u578B\u5B9A\u6570\u306E\u30B5\u30DE\u30EA\u30FC
    4.36 +doclet.Constructor_Summary=\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u30B5\u30DE\u30EA\u30FC
    4.37 +doclet.Method_Summary=\u30E1\u30BD\u30C3\u30C9\u306E\u30B5\u30DE\u30EA\u30FC
    4.38  doclet.Interfaces=\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9
    4.39  doclet.Enums=\u5217\u6319\u578B
    4.40  doclet.AnnotationTypes=\u6CE8\u91C8\u578B

     5.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/Extern.java	Mon May 19 22:00:11 2014 -0700
     5.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/Extern.java	Thu May 29 13:46:36 2014 -0700
     5.3 @@ -1,5 +1,5 @@
     5.4  /*
     5.5 - * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
     5.6 + * Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
     5.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     5.8   *
     5.9   * This code is free software; you can redistribute it and/or modify it
    5.10 @@ -177,7 +177,7 @@
    5.11          try {
    5.12              url = adjustEndFileSeparator(url);
    5.13              if (isUrl(pkglisturl)) {
    5.14 -                readPackageListFromURL(url, toURL(pkglisturl));
    5.15 +                readPackageListFromURL(url, toURL(adjustEndFileSeparator(pkglisturl)));
    5.16              } else {
    5.17                  readPackageListFromFile(url, DocFile.createFileForInput(configuration, pkglisturl));
    5.18              }

     6.1 --- a/src/share/classes/com/sun/tools/javac/code/Source.java	Mon May 19 22:00:11 2014 -0700
     6.2 +++ b/src/share/classes/com/sun/tools/javac/code/Source.java	Thu May 29 13:46:36 2014 -0700
     6.3 @@ -1,5 +1,5 @@
     6.4  /*
     6.5 - * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
     6.6 + * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
     6.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     6.8   *
     6.9   * This code is free software; you can redistribute it and/or modify it
    6.10 @@ -191,6 +191,9 @@
    6.11      public boolean allowObjectToPrimitiveCast() {
    6.12          return compareTo(JDK1_7) >= 0;
    6.13      }
    6.14 +    public boolean enforceThisDotInit() {
    6.15 +        return compareTo(JDK1_7) >= 0;
    6.16 +    }
    6.17      public boolean allowPoly() {
    6.18          return compareTo(JDK1_8) >= 0;
    6.19      }
    6.20 @@ -215,6 +218,9 @@
    6.21      public boolean allowTypeAnnotations() {
    6.22          return compareTo(JDK1_8) >= 0;
    6.23      }
    6.24 +    public boolean allowAnnotationsAfterTypeParams() {
    6.25 +        return compareTo(JDK1_8) >= 0;
    6.26 +    }
    6.27      public boolean allowRepeatedAnnotations() {
    6.28          return compareTo(JDK1_8) >= 0;
    6.29      }
    6.30 @@ -224,7 +230,7 @@
    6.31      public boolean allowGraphInference() {
    6.32          return compareTo(JDK1_8) >= 0;
    6.33      }
    6.34 -    public boolean allowStructuralMostSpecific() {
    6.35 +    public boolean allowFunctionalInterfaceMostSpecific() {
    6.36          return compareTo(JDK1_8) >= 0;
    6.37      }
    6.38      public static SourceVersion toSourceVersion(Source source) {

     7.1 --- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Mon May 19 22:00:11 2014 -0700
     7.2 +++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Thu May 29 13:46:36 2014 -0700
     7.3 @@ -1,5 +1,5 @@
     7.4  /*
     7.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
     7.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
     7.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     7.8   *
     7.9   * This code is free software; you can redistribute it and/or modify it
    7.10 @@ -392,7 +392,7 @@
    7.11      /** A class is an inner class if it it has an enclosing instance class.
    7.12       */
    7.13      public boolean isInner() {
    7.14 -        return type.getEnclosingType().hasTag(CLASS);
    7.15 +        return kind == TYP && type.getEnclosingType().hasTag(CLASS);
    7.16      }
    7.17  
    7.18      /** An inner class has an outer instance if it is not an interface
    7.19 @@ -467,11 +467,24 @@
    7.20  
    7.21      private boolean hiddenIn(ClassSymbol clazz, Types types) {
    7.22          Symbol sym = hiddenInInternal(clazz, types);
    7.23 -        return sym != null && sym != this;
    7.24 +        Assert.check(sym != null, "the result of hiddenInInternal() can't be null");
    7.25 +        /* If we find the current symbol then there is no symbol hiding it
    7.26 +         */
    7.27 +        return sym != this;
    7.28      }
    7.29  
    7.30 -    private Symbol hiddenInInternal(ClassSymbol c, Types types) {
    7.31 -        Scope.Entry e = c.members().lookup(name);
    7.32 +    /** This method looks in the supertypes graph that has the current class as the
    7.33 +     * initial node, till it finds the current symbol or another symbol that hides it.
    7.34 +     * If the current class has more than one supertype (extends one class and
    7.35 +     * implements one or more interfaces) then null can be returned, meaning that
    7.36 +     * a wrong path in the supertypes graph was selected. Null can only be returned
    7.37 +     * as a temporary value, as a result of the recursive call.
    7.38 +     */
    7.39 +    private Symbol hiddenInInternal(ClassSymbol currentClass, Types types) {
    7.40 +        if (currentClass == owner) {
    7.41 +            return this;
    7.42 +        }
    7.43 +        Scope.Entry e = currentClass.members().lookup(name);
    7.44          while (e.scope != null) {
    7.45              if (e.sym.kind == kind &&
    7.46                      (kind != MTH ||
    7.47 @@ -481,18 +494,19 @@
    7.48              }
    7.49              e = e.next();
    7.50          }
    7.51 -        List<Symbol> hiddenSyms = List.nil();
    7.52 -        for (Type st : types.interfaces(c.type).prepend(types.supertype(c.type))) {
    7.53 +        Symbol hiddenSym = null;
    7.54 +        for (Type st : types.interfaces(currentClass.type)
    7.55 +                .prepend(types.supertype(currentClass.type))) {
    7.56              if (st != null && (st.hasTag(CLASS))) {
    7.57                  Symbol sym = hiddenInInternal((ClassSymbol)st.tsym, types);
    7.58 -                if (sym != null) {
    7.59 -                    hiddenSyms = hiddenSyms.prepend(hiddenInInternal((ClassSymbol)st.tsym, types));
    7.60 +                if (sym == this) {
    7.61 +                    return this;
    7.62 +                } else if (sym != null) {
    7.63 +                    hiddenSym = sym;
    7.64                  }
    7.65              }
    7.66          }
    7.67 -        return hiddenSyms.contains(this) ?
    7.68 -                this :
    7.69 -                (hiddenSyms.isEmpty() ? null : hiddenSyms.head);
    7.70 +        return hiddenSym;
    7.71      }
    7.72  
    7.73      /** Is this symbol inherited into a given class?
    7.74 @@ -689,10 +703,10 @@
    7.75          }
    7.76  
    7.77          /**
    7.78 -         * A total ordering between type symbols that refines the
    7.79 +         * A partial ordering between type symbols that refines the
    7.80           * class inheritance graph.
    7.81           *
    7.82 -         * Typevariables always precede other kinds of symbols.
    7.83 +         * Type variables always precede other kinds of symbols.
    7.84           */
    7.85          public final boolean precedes(TypeSymbol that, Types types) {
    7.86              if (this == that)

     8.1 --- a/src/share/classes/com/sun/tools/javac/code/Type.java	Mon May 19 22:00:11 2014 -0700
     8.2 +++ b/src/share/classes/com/sun/tools/javac/code/Type.java	Thu May 29 13:46:36 2014 -0700
     8.3 @@ -1,5 +1,5 @@
     8.4  /*
     8.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
     8.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
     8.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.8   *
     8.9   * This code is free software; you can redistribute it and/or modify it
    8.10 @@ -1445,12 +1445,19 @@
    8.11           * Inference variable bound kinds
    8.12           */
    8.13          public enum InferenceBound {
    8.14 -            /** upper bounds */
    8.15 -            UPPER,
    8.16 -            /** lower bounds */
    8.17 -            LOWER,
    8.18 -            /** equality constraints */
    8.19 -            EQ;
    8.20 +            UPPER {
    8.21 +                public InferenceBound complement() { return LOWER; }
    8.22 +            },
    8.23 +             /** lower bounds */
    8.24 +            LOWER {
    8.25 +                public InferenceBound complement() { return UPPER; }
    8.26 +            },
    8.27 +             /** equality constraints */
    8.28 +            EQ {
    8.29 +                public InferenceBound complement() { return EQ; }
    8.30 +            };
    8.31 +
    8.32 +            public abstract InferenceBound complement();
    8.33          }
    8.34  
    8.35          /** inference variable bounds */
    8.36 @@ -1481,8 +1488,21 @@
    8.37          }
    8.38  
    8.39          public String toString() {
    8.40 -            if (inst != null) return inst.toString();
    8.41 -            else return qtype + "?";
    8.42 +            return (inst == null) ? qtype + "?" : inst.toString();
    8.43 +        }
    8.44 +
    8.45 +        public String debugString() {
    8.46 +            String result = "inference var = " + qtype + "\n";
    8.47 +            if (inst != null) {
    8.48 +                result += "inst = " + inst + '\n';
    8.49 +            }
    8.50 +            for (InferenceBound bound: InferenceBound.values()) {
    8.51 +                List<Type> aboundList = bounds.get(bound);
    8.52 +                if (aboundList.size() > 0) {
    8.53 +                    result += bound + " = " + aboundList + '\n';
    8.54 +                }
    8.55 +            }
    8.56 +            return result;
    8.57          }
    8.58  
    8.59          @Override
    8.60 @@ -1492,8 +1512,7 @@
    8.61  
    8.62          @Override
    8.63          public Type baseType() {
    8.64 -            if (inst != null) return inst.baseType();
    8.65 -            else return this;
    8.66 +            return (inst == null) ? this : inst.baseType();
    8.67          }
    8.68  
    8.69          /** get all bounds of a given kind */
    8.70 @@ -1624,6 +1643,9 @@
    8.71                  //only change bounds if request comes from substBounds
    8.72                  super.addBound(ib, bound, types, update);
    8.73              }
    8.74 +            else if (bound.hasTag(UNDETVAR) && !((UndetVar) bound).isCaptured()) {
    8.75 +                ((UndetVar) bound).addBound(ib.complement(), this, types, false);
    8.76 +            }
    8.77          }
    8.78  
    8.79          @Override

     9.1 --- a/src/share/classes/com/sun/tools/javac/code/Types.java	Mon May 19 22:00:11 2014 -0700
     9.2 +++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Thu May 29 13:46:36 2014 -0700
     9.3 @@ -1,5 +1,5 @@
     9.4  /*
     9.5 - * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
     9.6 + * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
     9.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     9.8   *
     9.9   * This code is free software; you can redistribute it and/or modify it
    9.10 @@ -43,6 +43,7 @@
    9.11  import com.sun.tools.javac.comp.Enter;
    9.12  import com.sun.tools.javac.comp.Env;
    9.13  import com.sun.tools.javac.jvm.ClassReader;
    9.14 +import com.sun.tools.javac.tree.JCTree;
    9.15  import com.sun.tools.javac.util.*;
    9.16  import static com.sun.tools.javac.code.BoundKind.*;
    9.17  import static com.sun.tools.javac.code.Flags.*;
    9.18 @@ -84,7 +85,6 @@
    9.19      final boolean allowBoxing;
    9.20      final boolean allowCovariantReturns;
    9.21      final boolean allowObjectToPrimitiveCast;
    9.22 -    final boolean allowDefaultMethods;
    9.23      final ClassReader reader;
    9.24      final Check chk;
    9.25      final Enter enter;
    9.26 @@ -111,7 +111,6 @@
    9.27          allowBoxing = source.allowBoxing();
    9.28          allowCovariantReturns = source.allowCovariantReturns();
    9.29          allowObjectToPrimitiveCast = source.allowObjectToPrimitiveCast();
    9.30 -        allowDefaultMethods = source.allowDefaultMethods();
    9.31          reader = ClassReader.instance(context);
    9.32          chk = Check.instance(context);
    9.33          enter = Enter.instance(context);
    9.34 @@ -153,31 +152,31 @@
    9.35          };
    9.36      // </editor-fold>
    9.37  
    9.38 -    // <editor-fold defaultstate="collapsed" desc="lowerBound">
    9.39 +    // <editor-fold defaultstate="collapsed" desc="wildLowerBound">
    9.40      /**
    9.41 -     * The "lvalue conversion".<br>
    9.42 -     * The lower bound of most types is the type
    9.43 -     * itself.  Wildcards, on the other hand have upper
    9.44 -     * and lower bounds.
    9.45 +     * Get a wildcard's lower bound, returning non-wildcards unchanged.
    9.46 +     * @param t a type argument, either a wildcard or a type
    9.47 +     */
    9.48 +    public Type wildLowerBound(Type t) {
    9.49 +        if (t.hasTag(WILDCARD)) {
    9.50 +            WildcardType w = (WildcardType) t;
    9.51 +            return w.isExtendsBound() ? syms.botType : wildLowerBound(w.type);
    9.52 +        }
    9.53 +        else return t;
    9.54 +    }
    9.55 +    // </editor-fold>
    9.56 +
    9.57 +    // <editor-fold defaultstate="collapsed" desc="cvarLowerBound">
    9.58 +    /**
    9.59 +     * Get a capture variable's lower bound, returning other types unchanged.
    9.60       * @param t a type
    9.61 -     * @return the lower bound of the given type
    9.62       */
    9.63 -    public Type lowerBound(Type t) {
    9.64 -        return lowerBound.visit(t);
    9.65 +    public Type cvarLowerBound(Type t) {
    9.66 +        if (t.hasTag(TYPEVAR) && ((TypeVar) t).isCaptured()) {
    9.67 +            return cvarLowerBound(t.getLowerBound());
    9.68 +        }
    9.69 +        else return t;
    9.70      }
    9.71 -    // where
    9.72 -        private final MapVisitor<Void> lowerBound = new MapVisitor<Void>() {
    9.73 -
    9.74 -            @Override
    9.75 -            public Type visitWildcardType(WildcardType t, Void ignored) {
    9.76 -                return t.isExtendsBound() ? syms.botType : visit(t.type);
    9.77 -            }
    9.78 -
    9.79 -            @Override
    9.80 -            public Type visitCapturedType(CapturedType t, Void ignored) {
    9.81 -                return visit(t.getLowerBound());
    9.82 -            }
    9.83 -        };
    9.84      // </editor-fold>
    9.85  
    9.86      // <editor-fold defaultstate="collapsed" desc="isUnbounded">
    9.87 @@ -307,8 +306,8 @@
    9.88      }
    9.89  
    9.90      /**
    9.91 -     * Is t a subtype of or convertiable via boxing/unboxing
    9.92 -     * convertions to s?
    9.93 +     * Is t a subtype of or convertible via boxing/unboxing
    9.94 +     * conversions to s?
    9.95       */
    9.96      public boolean isConvertible(Type t, Type s) {
    9.97          return isConvertible(t, s, noWarnings);
    9.98 @@ -829,9 +828,15 @@
    9.99              return true;
   9.100          }
   9.101  
   9.102 -        Type lower = lowerBound(s);
   9.103 -        if (s != lower)
   9.104 -            return isSubtype(capture ? capture(t) : t, lower, false);
   9.105 +        // Generally, if 's' is a type variable, recur on lower bound; but
   9.106 +        // for inference variables and intersections, we need to keep 's'
   9.107 +        // (see JLS 4.10.2 for intersections and 18.2.3 for inference vars)
   9.108 +        if (!t.hasTag(UNDETVAR) && !t.isCompound()) {
   9.109 +            // TODO: JDK-8039198, bounds checking sometimes passes in a wildcard as s
   9.110 +            Type lower = cvarLowerBound(wildLowerBound(s));
   9.111 +            if (s != lower)
   9.112 +                return isSubtype(capture ? capture(t) : t, lower, false);
   9.113 +        }
   9.114  
   9.115          return isSubtype.visit(capture ? capture(t) : t, s);
   9.116      }
   9.117 @@ -915,14 +920,11 @@
   9.118              @Override
   9.119              public Boolean visitClassType(ClassType t, Type s) {
   9.120                  Type sup = asSuper(t, s.tsym);
   9.121 -                return sup != null
   9.122 -                    && sup.tsym == s.tsym
   9.123 -                    // You're not allowed to write
   9.124 -                    //     Vector<Object> vec = new Vector<String>();
   9.125 -                    // But with wildcards you can write
   9.126 -                    //     Vector<? extends Object> vec = new Vector<String>();
   9.127 -                    // which means that subtype checking must be done
   9.128 -                    // here instead of same-type checking (via containsType).
   9.129 +                if (sup == null) return false;
   9.130 +                // If t is an intersection, sup might not be a class type
   9.131 +                if (!sup.hasTag(CLASS)) return isSubtypeNoCapture(sup, s);
   9.132 +                return sup.tsym == s.tsym
   9.133 +                     // Check type variable containment
   9.134                      && (!s.isParameterized() || containsTypeRecursive(s, sup))
   9.135                      && isSubtypeNoCapture(sup.getEnclosingType(),
   9.136                                            s.getEnclosingType());
   9.137 @@ -1138,7 +1140,7 @@
   9.138                      return visit(s, t);
   9.139  
   9.140                  if (s.isSuperBound() && !s.isExtendsBound())
   9.141 -                    return visit(t, upperBound(s)) && visit(t, lowerBound(s));
   9.142 +                    return visit(t, upperBound(s)) && visit(t, wildLowerBound(s));
   9.143  
   9.144                  if (t.isCompound() && s.isCompound()) {
   9.145                      if (!visit(supertype(t), supertype(s)))
   9.146 @@ -1293,7 +1295,7 @@
   9.147                          break;
   9.148                      }
   9.149                      case SUPER: {
   9.150 -                        Type bound = lowerBound(s);
   9.151 +                        Type bound = wildLowerBound(s);
   9.152                          undetvar.addBound(InferenceBound.LOWER, bound, this);
   9.153                          break;
   9.154                      }
   9.155 @@ -1386,9 +1388,9 @@
   9.156  //                                  t.isSuperBound()
   9.157  //                                  || isSubtypeNoCapture(upperBound(s), U(t)));
   9.158  //                System.err.format(" %s L(%s) <: L(%s) %s = %s%n",
   9.159 -//                                  L(t), t, s, lowerBound(s),
   9.160 +//                                  L(t), t, s, wildLowerBound(s),
   9.161  //                                  t.isExtendsBound()
   9.162 -//                                  || isSubtypeNoCapture(L(t), lowerBound(s)));
   9.163 +//                                  || isSubtypeNoCapture(L(t), wildLowerBound(s)));
   9.164  //                System.err.println();
   9.165  //            }
   9.166  
   9.167 @@ -1400,7 +1402,7 @@
   9.168  //                    debugContainsType(t, s);
   9.169                      return isSameWildcard(t, s)
   9.170                          || isCaptureOf(s, t)
   9.171 -                        || ((t.isExtendsBound() || isSubtypeNoCapture(L(t), lowerBound(s))) &&
   9.172 +                        || ((t.isExtendsBound() || isSubtypeNoCapture(L(t), wildLowerBound(s))) &&
   9.173                              (t.isSuperBound() || isSubtypeNoCapture(upperBound(s), U(t))));
   9.174                  }
   9.175              }
   9.176 @@ -1762,7 +1764,7 @@
   9.177                      if (s.isExtendsBound())
   9.178                          return !isCastableRecursive(t.type, upperBound(s));
   9.179                      else if (s.isSuperBound())
   9.180 -                        return notSoftSubtypeRecursive(lowerBound(s), t.type);
   9.181 +                        return notSoftSubtypeRecursive(wildLowerBound(s), t.type);
   9.182                  } else if (t.isSuperBound()) {
   9.183                      if (s.isExtendsBound())
   9.184                          return notSoftSubtypeRecursive(t.type, upperBound(s));
   9.185 @@ -1772,19 +1774,13 @@
   9.186          };
   9.187      // </editor-fold>
   9.188  
   9.189 -    // <editor-fold defaultstate="collapsed" desc="lowerBoundArgtypes">
   9.190 -    /**
   9.191 -     * Returns the lower bounds of the formals of a method.
   9.192 -     */
   9.193 -    public List<Type> lowerBoundArgtypes(Type t) {
   9.194 -        return lowerBounds(t.getParameterTypes());
   9.195 +    // <editor-fold defaultstate="collapsed" desc="cvarLowerBounds">
   9.196 +    public List<Type> cvarLowerBounds(List<Type> ts) {
   9.197 +        return map(ts, cvarLowerBoundMapping);
   9.198      }
   9.199 -    public List<Type> lowerBounds(List<Type> ts) {
   9.200 -        return map(ts, lowerBoundMapping);
   9.201 -    }
   9.202 -    private final Mapping lowerBoundMapping = new Mapping("lowerBound") {
   9.203 +    private final Mapping cvarLowerBoundMapping = new Mapping("cvarLowerBound") {
   9.204              public Type apply(Type t) {
   9.205 -                return lowerBound(t);
   9.206 +                return cvarLowerBound(t);
   9.207              }
   9.208          };
   9.209      // </editor-fold>
   9.210 @@ -1936,6 +1932,17 @@
   9.211       * @param sym a symbol
   9.212       */
   9.213      public Type asSuper(Type t, Symbol sym) {
   9.214 +        /* Some examples:
   9.215 +         *
   9.216 +         * (Enum<E>, Comparable) => Comparable<E>
   9.217 +         * (c.s.s.d.AttributeTree.ValueKind, Enum) => Enum<c.s.s.d.AttributeTree.ValueKind>
   9.218 +         * (c.s.s.t.ExpressionTree, c.s.s.t.Tree) => c.s.s.t.Tree
   9.219 +         * (j.u.List<capture#160 of ? extends c.s.s.d.DocTree>, Iterable) =>
   9.220 +         *     Iterable<capture#160 of ? extends c.s.s.d.DocTree>
   9.221 +         */
   9.222 +        if (sym.type == syms.objectType) { //optimization
   9.223 +            return syms.objectType;
   9.224 +        }
   9.225          return asSuper.visit(t, sym);
   9.226      }
   9.227      // where
   9.228 @@ -1951,16 +1958,18 @@
   9.229                      return t;
   9.230  
   9.231                  Type st = supertype(t);
   9.232 -                if (st.hasTag(CLASS) || st.hasTag(TYPEVAR) || st.hasTag(ERROR)) {
   9.233 +                if (st.hasTag(CLASS) || st.hasTag(TYPEVAR)) {
   9.234                      Type x = asSuper(st, sym);
   9.235                      if (x != null)
   9.236                          return x;
   9.237                  }
   9.238                  if ((sym.flags() & INTERFACE) != 0) {
   9.239                      for (List<Type> l = interfaces(t); l.nonEmpty(); l = l.tail) {
   9.240 -                        Type x = asSuper(l.head, sym);
   9.241 -                        if (x != null)
   9.242 -                            return x;
   9.243 +                        if (!l.head.hasTag(ERROR)) {
   9.244 +                            Type x = asSuper(l.head, sym);
   9.245 +                            if (x != null)
   9.246 +                                return x;
   9.247 +                        }
   9.248                      }
   9.249                  }
   9.250                  return null;
   9.251 @@ -2242,7 +2251,8 @@
   9.252  
   9.253      // <editor-fold defaultstate="collapsed" desc="makeCompoundType">
   9.254      /**
   9.255 -     * Make a compound type from non-empty list of types
   9.256 +     * Make a compound type from non-empty list of types.  The list should be
   9.257 +     * ordered according to {@link Symbol#precedes(TypeSymbol,Types)}.
   9.258       *
   9.259       * @param bounds            the types from which the compound type is formed
   9.260       * @param supertype         is objectType if all bounds are interfaces,
   9.261 @@ -3332,12 +3342,15 @@
   9.262       * Insert a type in a closure
   9.263       */
   9.264      public List<Type> insert(List<Type> cl, Type t) {
   9.265 -        if (cl.isEmpty() || t.tsym.precedes(cl.head.tsym, this)) {
   9.266 +        if (cl.isEmpty()) {
   9.267              return cl.prepend(t);
   9.268 -        } else if (cl.head.tsym.precedes(t.tsym, this)) {
   9.269 +        } else if (t.tsym == cl.head.tsym) {
   9.270 +            return cl;
   9.271 +        } else if (t.tsym.precedes(cl.head.tsym, this)) {
   9.272 +            return cl.prepend(t);
   9.273 +        } else {
   9.274 +            // t comes after head, or the two are unrelated
   9.275              return insert(cl.tail, t).prepend(cl.head);
   9.276 -        } else {
   9.277 -            return cl;
   9.278          }
   9.279      }
   9.280  
   9.281 @@ -3349,12 +3362,15 @@
   9.282              return cl2;
   9.283          } else if (cl2.isEmpty()) {
   9.284              return cl1;
   9.285 +        } else if (cl1.head.tsym == cl2.head.tsym) {
   9.286 +            return union(cl1.tail, cl2.tail).prepend(cl1.head);
   9.287          } else if (cl1.head.tsym.precedes(cl2.head.tsym, this)) {
   9.288              return union(cl1.tail, cl2).prepend(cl1.head);
   9.289          } else if (cl2.head.tsym.precedes(cl1.head.tsym, this)) {
   9.290              return union(cl1, cl2.tail).prepend(cl2.head);
   9.291          } else {
   9.292 -            return union(cl1.tail, cl2.tail).prepend(cl1.head);
   9.293 +            // unrelated types
   9.294 +            return union(cl1.tail, cl2).prepend(cl1.head);
   9.295          }
   9.296      }
   9.297  
   9.298 @@ -3464,18 +3480,31 @@
   9.299      private List<Type> closureMin(List<Type> cl) {
   9.300          ListBuffer<Type> classes = new ListBuffer<>();
   9.301          ListBuffer<Type> interfaces = new ListBuffer<>();
   9.302 +        Set<Type> toSkip = new HashSet<>();
   9.303          while (!cl.isEmpty()) {
   9.304              Type current = cl.head;
   9.305 -            if (current.isInterface())
   9.306 -                interfaces.append(current);
   9.307 -            else
   9.308 -                classes.append(current);
   9.309 -            ListBuffer<Type> candidates = new ListBuffer<>();
   9.310 -            for (Type t : cl.tail) {
   9.311 -                if (!isSubtypeNoCapture(current, t))
   9.312 -                    candidates.append(t);
   9.313 +            boolean keep = !toSkip.contains(current);
   9.314 +            if (keep && current.hasTag(TYPEVAR)) {
   9.315 +                // skip lower-bounded variables with a subtype in cl.tail
   9.316 +                for (Type t : cl.tail) {
   9.317 +                    if (isSubtypeNoCapture(t, current)) {
   9.318 +                        keep = false;
   9.319 +                        break;
   9.320 +                    }
   9.321 +                }
   9.322              }
   9.323 -            cl = candidates.toList();
   9.324 +            if (keep) {
   9.325 +                if (current.isInterface())
   9.326 +                    interfaces.append(current);
   9.327 +                else
   9.328 +                    classes.append(current);
   9.329 +                for (Type t : cl.tail) {
   9.330 +                    // skip supertypes of 'current' in cl.tail
   9.331 +                    if (isSubtypeNoCapture(current, t))
   9.332 +                        toSkip.add(t);
   9.333 +                }
   9.334 +            }
   9.335 +            cl = cl.tail;
   9.336          }
   9.337          return classes.appendList(interfaces).toList();
   9.338      }
   9.339 @@ -3635,7 +3664,19 @@
   9.340              return s;
   9.341  
   9.342          List<Type> closure = union(closure(t), closure(s));
   9.343 -        List<Type> bounds = closureMin(closure);
   9.344 +        return glbFlattened(closure, t);
   9.345 +    }
   9.346 +    //where
   9.347 +    /**
   9.348 +     * Perform glb for a list of non-primitive, non-error, non-compound types;
   9.349 +     * redundant elements are removed.  Bounds should be ordered according to
   9.350 +     * {@link Symbol#precedes(TypeSymbol,Types)}.
   9.351 +     *
   9.352 +     * @param flatBounds List of type to glb
   9.353 +     * @param errT Original type to use if the result is an error type
   9.354 +     */
   9.355 +    private Type glbFlattened(List<Type> flatBounds, Type errT) {
   9.356 +        List<Type> bounds = closureMin(flatBounds);
   9.357  
   9.358          if (bounds.isEmpty()) {             // length == 0
   9.359              return syms.objectType;
   9.360 @@ -3643,11 +3684,21 @@
   9.361              return bounds.head;
   9.362          } else {                            // length > 1
   9.363              int classCount = 0;
   9.364 -            for (Type bound : bounds)
   9.365 -                if (!bound.isInterface())
   9.366 +            List<Type> lowers = List.nil();
   9.367 +            for (Type bound : bounds) {
   9.368 +                if (!bound.isInterface()) {
   9.369                      classCount++;
   9.370 -            if (classCount > 1)
   9.371 -                return createErrorType(t);
   9.372 +                    Type lower = cvarLowerBound(bound);
   9.373 +                    if (bound != lower && !lower.hasTag(BOT))
   9.374 +                        lowers = insert(lowers, lower);
   9.375 +                }
   9.376 +            }
   9.377 +            if (classCount > 1) {
   9.378 +                if (lowers.isEmpty())
   9.379 +                    return createErrorType(errT);
   9.380 +                else
   9.381 +                    return glbFlattened(union(bounds, lowers), errT);
   9.382 +            }
   9.383          }
   9.384          return makeCompoundType(bounds);
   9.385      }
   9.386 @@ -3871,9 +3922,11 @@
   9.387          }
   9.388          return buf.reverse();
   9.389      }
   9.390 +
   9.391      public Type capture(Type t) {
   9.392 -        if (!t.hasTag(CLASS))
   9.393 +        if (!t.hasTag(CLASS)) {
   9.394              return t;
   9.395 +        }
   9.396          if (t.getEnclosingType() != Type.noType) {
   9.397              Type capturedEncl = capture(t.getEnclosingType());
   9.398              if (capturedEncl != t.getEnclosingType()) {
   9.399 @@ -4125,7 +4178,7 @@
   9.400              if (source.isExtendsBound())
   9.401                  adaptRecursive(upperBound(source), upperBound(target));
   9.402              else if (source.isSuperBound())
   9.403 -                adaptRecursive(lowerBound(source), lowerBound(target));
   9.404 +                adaptRecursive(wildLowerBound(source), wildLowerBound(target));
   9.405              return null;
   9.406          }
   9.407  
   9.408 @@ -4137,7 +4190,7 @@
   9.409              Type val = mapping.get(source.tsym);
   9.410              if (val != null) {
   9.411                  if (val.isSuperBound() && target.isSuperBound()) {
   9.412 -                    val = isSubtype(lowerBound(val), lowerBound(target))
   9.413 +                    val = isSubtype(wildLowerBound(val), wildLowerBound(target))
   9.414                          ? target : val;
   9.415                  } else if (val.isExtendsBound() && target.isExtendsBound()) {
   9.416                      val = isSubtype(upperBound(val), upperBound(target))
   9.417 @@ -4251,7 +4304,7 @@
   9.418          }
   9.419  
   9.420          public Type visitType(Type t, Void s) {
   9.421 -            return high ? upperBound(t) : lowerBound(t);
   9.422 +            return high ? upperBound(t) : t;
   9.423          }
   9.424  
   9.425          @Override

    10.1 --- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Mon May 19 22:00:11 2014 -0700
    10.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Thu May 29 13:46:36 2014 -0700
    10.3 @@ -1,5 +1,5 @@
    10.4  /*
    10.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    10.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    10.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    10.8   *
    10.9   * This code is free software; you can redistribute it and/or modify it
   10.10 @@ -249,7 +249,7 @@
   10.11          if (!owntype.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {
   10.12              if (allowPoly && inferenceContext.free(found)) {
   10.13                  if ((ownkind & ~resultInfo.pkind) == 0) {
   10.14 -                    owntype = resultInfo.check(tree, inferenceContext.asFree(owntype));
   10.15 +                    owntype = resultInfo.check(tree, inferenceContext.asUndetVar(owntype));
   10.16                  } else {
   10.17                      log.error(tree.pos(), "unexpected.type",
   10.18                              kindNames(resultInfo.pkind),
   10.19 @@ -518,6 +518,10 @@
   10.20              return new ResultInfo(pkind, pt, newContext);
   10.21          }
   10.22  
   10.23 +        protected ResultInfo dup(Type newPt, CheckContext newContext) {
   10.24 +            return new ResultInfo(pkind, newPt, newContext);
   10.25 +        }
   10.26 +
   10.27          @Override
   10.28          public String toString() {
   10.29              if (pt != null) {
   10.30 @@ -812,6 +816,10 @@
   10.31                     boolean classExpected,
   10.32                     boolean interfaceExpected,
   10.33                     boolean checkExtensible) {
   10.34 +        if (t.tsym.isAnonymous()) {
   10.35 +            log.error(tree.pos(), "cant.inherit.from.anon");
   10.36 +            return types.createErrorType(t);
   10.37 +        }
   10.38          if (t.isErroneous())
   10.39              return t;
   10.40          if (t.hasTag(TYPEVAR) && !classExpected && !interfaceExpected) {
   10.41 @@ -2139,6 +2147,11 @@
   10.42                      cdef.extending = clazz;
   10.43                  }
   10.44  
   10.45 +                if (resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK &&
   10.46 +                    isSerializable(clazztype)) {
   10.47 +                    localEnv.info.isSerializable = true;
   10.48 +                }
   10.49 +
   10.50                  attribStat(cdef, localEnv);
   10.51  
   10.52                  checkLambdaCandidate(tree, cdef.sym, clazztype);
   10.53 @@ -2294,6 +2307,9 @@
   10.54                  resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK;
   10.55          try {
   10.56              Type currentTarget = pt();
   10.57 +            if (needsRecovery && isSerializable(currentTarget)) {
   10.58 +                localEnv.info.isSerializable = true;
   10.59 +            }
   10.60              List<Type> explicitParamTypes = null;
   10.61              if (that.paramKind == JCLambda.ParameterKind.EXPLICIT) {
   10.62                  //attribute lambda parameters
   10.63 @@ -2398,7 +2414,7 @@
   10.64                  //add thrown types as bounds to the thrown types free variables if needed:
   10.65                  if (resultInfo.checkContext.inferenceContext().free(lambdaType.getThrownTypes())) {
   10.66                      List<Type> inferredThrownTypes = flow.analyzeLambdaThrownTypes(env, that, make);
   10.67 -                    List<Type> thrownTypes = resultInfo.checkContext.inferenceContext().asFree(lambdaType.getThrownTypes());
   10.68 +                    List<Type> thrownTypes = resultInfo.checkContext.inferenceContext().asUndetVars(lambdaType.getThrownTypes());
   10.69  
   10.70                      chk.unhandled(inferredThrownTypes, thrownTypes);
   10.71                  }
   10.72 @@ -2539,7 +2555,7 @@
   10.73              @Override
   10.74              public boolean compatible(Type found, Type req, Warner warn) {
   10.75                  //return type must be compatible in both current context and assignment context
   10.76 -                return chk.basicHandler.compatible(found, inferenceContext().asFree(req), warn);
   10.77 +                return chk.basicHandler.compatible(found, inferenceContext().asUndetVar(req), warn);
   10.78              }
   10.79  
   10.80              @Override
   10.81 @@ -2572,7 +2588,7 @@
   10.82          * types must be compatible with the return type of the expected descriptor.
   10.83          */
   10.84          private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
   10.85 -            Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());
   10.86 +            Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());
   10.87  
   10.88              //return values have already been checked - but if lambda has no return
   10.89              //values, we must ensure that void/value compatibility is correct;
   10.90 @@ -2584,7 +2600,7 @@
   10.91                          diags.fragment("missing.ret.val", returnType)));
   10.92              }
   10.93  
   10.94 -            List<Type> argTypes = checkContext.inferenceContext().asFree(descriptor.getParameterTypes());
   10.95 +            List<Type> argTypes = checkContext.inferenceContext().asUndetVars(descriptor.getParameterTypes());
   10.96              if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
   10.97                  checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
   10.98              }
   10.99 @@ -2614,7 +2630,7 @@
  10.100           * - an instance field, we use the first constructor.
  10.101           * - a static field, we create a fake clinit method.
  10.102           */
  10.103 -        private Env<AttrContext> lambdaEnv(JCLambda that, Env<AttrContext> env) {
  10.104 +        public Env<AttrContext> lambdaEnv(JCLambda that, Env<AttrContext> env) {
  10.105              Env<AttrContext> lambdaEnv;
  10.106              Symbol owner = env.info.scope.owner;
  10.107              if (owner.kind == VAR && owner.owner.kind == TYP) {
  10.108 @@ -2698,17 +2714,20 @@
  10.109                  typeargtypes = attribTypes(that.typeargs, localEnv);
  10.110              }
  10.111  
  10.112 -            Type target;
  10.113              Type desc;
  10.114 -            if (pt() != Type.recoveryType) {
  10.115 -                target = targetChecker.visit(pt(), that);
  10.116 -                desc = types.findDescriptorType(target);
  10.117 +            Type currentTarget = pt();
  10.118 +            boolean isTargetSerializable =
  10.119 +                    resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK &&
  10.120 +                    isSerializable(currentTarget);
  10.121 +            if (currentTarget != Type.recoveryType) {
  10.122 +                currentTarget = targetChecker.visit(currentTarget, that);
  10.123 +                desc = types.findDescriptorType(currentTarget);
  10.124              } else {
  10.125 -                target = Type.recoveryType;
  10.126 +                currentTarget = Type.recoveryType;
  10.127                  desc = fallbackDescriptorType(that);
  10.128              }
  10.129  
  10.130 -            setFunctionalInfo(localEnv, that, pt(), desc, target, resultInfo.checkContext);
  10.131 +            setFunctionalInfo(localEnv, that, pt(), desc, currentTarget, resultInfo.checkContext);
  10.132              List<Type> argtypes = desc.getParameterTypes();
  10.133              Resolve.MethodCheck referenceCheck = rs.resolveMethodCheck;
  10.134  
  10.135 @@ -2750,7 +2769,7 @@
  10.136                          targetError = false;
  10.137                  }
  10.138  
  10.139 -                JCDiagnostic detailsDiag = ((Resolve.ResolveError)refSym).getDiagnostic(JCDiagnostic.DiagnosticType.FRAGMENT,
  10.140 +                JCDiagnostic detailsDiag = ((Resolve.ResolveError)refSym.baseSymbol()).getDiagnostic(JCDiagnostic.DiagnosticType.FRAGMENT,
  10.141                                  that, exprType.tsym, exprType, that.name, argtypes, typeargtypes);
  10.142  
  10.143                  JCDiagnostic.DiagnosticType diagKind = targetError ?
  10.144 @@ -2759,10 +2778,10 @@
  10.145                  JCDiagnostic diag = diags.create(diagKind, log.currentSource(), that,
  10.146                          "invalid.mref", Kinds.kindName(that.getMode()), detailsDiag);
  10.147  
  10.148 -                if (targetError && target == Type.recoveryType) {
  10.149 +                if (targetError && currentTarget == Type.recoveryType) {
  10.150                      //a target error doesn't make sense during recovery stage
  10.151                      //as we don't know what actual parameter types are
  10.152 -                    result = that.type = target;
  10.153 +                    result = that.type = currentTarget;
  10.154                      return;
  10.155                  } else {
  10.156                      if (targetError) {
  10.157 @@ -2770,7 +2789,7 @@
  10.158                      } else {
  10.159                          log.report(diag);
  10.160                      }
  10.161 -                    result = that.type = types.createErrorType(target);
  10.162 +                    result = that.type = types.createErrorType(currentTarget);
  10.163                      return;
  10.164                  }
  10.165              }
  10.166 @@ -2781,7 +2800,7 @@
  10.167  
  10.168              if (desc.getReturnType() == Type.recoveryType) {
  10.169                  // stop here
  10.170 -                result = that.type = target;
  10.171 +                result = that.type = currentTarget;
  10.172                  return;
  10.173              }
  10.174  
  10.175 @@ -2799,7 +2818,7 @@
  10.176                      //static ref with class type-args
  10.177                      log.error(that.expr.pos(), "invalid.mref", Kinds.kindName(that.getMode()),
  10.178                              diags.fragment("static.mref.with.targs"));
  10.179 -                    result = that.type = types.createErrorType(target);
  10.180 +                    result = that.type = types.createErrorType(currentTarget);
  10.181                      return;
  10.182                  }
  10.183  
  10.184 @@ -2808,7 +2827,7 @@
  10.185                      //no static bound mrefs
  10.186                      log.error(that.expr.pos(), "invalid.mref", Kinds.kindName(that.getMode()),
  10.187                              diags.fragment("static.bound.mref"));
  10.188 -                    result = that.type = types.createErrorType(target);
  10.189 +                    result = that.type = types.createErrorType(currentTarget);
  10.190                      return;
  10.191                  }
  10.192  
  10.193 @@ -2816,19 +2835,24 @@
  10.194                      // Check that super-qualified symbols are not abstract (JLS)
  10.195                      rs.checkNonAbstract(that.pos(), that.sym);
  10.196                  }
  10.197 +
  10.198 +                if (isTargetSerializable) {
  10.199 +                    chk.checkElemAccessFromSerializableLambda(that);
  10.200 +                }
  10.201              }
  10.202  
  10.203              ResultInfo checkInfo =
  10.204                      resultInfo.dup(newMethodTemplate(
  10.205                          desc.getReturnType().hasTag(VOID) ? Type.noType : desc.getReturnType(),
  10.206 -                        that.kind.isUnbound() ? argtypes.tail : argtypes, typeargtypes));
  10.207 +                        that.kind.isUnbound() ? argtypes.tail : argtypes, typeargtypes),
  10.208 +                        new FunctionalReturnContext(resultInfo.checkContext));
  10.209  
  10.210              Type refType = checkId(that, lookupHelper.site, refSym, localEnv, checkInfo);
  10.211  
  10.212              if (that.kind.isUnbound() &&
  10.213                      resultInfo.checkContext.inferenceContext().free(argtypes.head)) {
  10.214                  //re-generate inference constraints for unbound receiver
  10.215 -                if (!types.isSubtype(resultInfo.checkContext.inferenceContext().asFree(argtypes.head), exprType)) {
  10.216 +                if (!types.isSubtype(resultInfo.checkContext.inferenceContext().asUndetVar(argtypes.head), exprType)) {
  10.217                      //cannot happen as this has already been checked - we just need
  10.218                      //to regenerate the inference constraints, as that has been lost
  10.219                      //as a result of the call to inferenceContext.save()
  10.220 @@ -2847,9 +2871,9 @@
  10.221                      resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
  10.222              checkReferenceCompatible(that, desc, refType, resultInfo.checkContext, isSpeculativeRound);
  10.223              if (!isSpeculativeRound) {
  10.224 -                checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), desc, target);
  10.225 +                checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), desc, currentTarget);
  10.226              }
  10.227 -            result = check(that, target, VAL, resultInfo);
  10.228 +            result = check(that, currentTarget, VAL, resultInfo);
  10.229          } catch (Types.FunctionDescriptorLookupError ex) {
  10.230              JCDiagnostic cause = ex.getDiagnostic();
  10.231              resultInfo.checkContext.report(that, cause);
  10.232 @@ -2866,7 +2890,7 @@
  10.233  
  10.234      @SuppressWarnings("fallthrough")
  10.235      void checkReferenceCompatible(JCMemberReference tree, Type descriptor, Type refType, CheckContext checkContext, boolean speculativeAttr) {
  10.236 -        Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());
  10.237 +        Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());
  10.238  
  10.239          Type resType;
  10.240          switch (tree.getMode()) {
  10.241 @@ -2898,7 +2922,7 @@
  10.242          }
  10.243  
  10.244          if (!speculativeAttr) {
  10.245 -            List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes());
  10.246 +            List<Type> thrownTypes = checkContext.inferenceContext().asUndetVars(descriptor.getThrownTypes());
  10.247              if (chk.unhandled(refType.getThrownTypes(), thrownTypes).nonEmpty()) {
  10.248                  log.error(tree, "incompatible.thrown.types.in.mref", refType.getThrownTypes());
  10.249              }
  10.250 @@ -3009,15 +3033,6 @@
  10.251                  Type ctype = cfolder.fold1(opc, argtype);
  10.252                  if (ctype != null) {
  10.253                      owntype = cfolder.coerce(ctype, owntype);
  10.254 -
  10.255 -                    // Remove constant types from arguments to
  10.256 -                    // conserve space. The parser will fold concatenations
  10.257 -                    // of string literals; the code here also
  10.258 -                    // gets rid of intermediate results when some of the
  10.259 -                    // operands are constant identifiers.
  10.260 -                    if (tree.arg.type.tsym == syms.stringType.tsym) {
  10.261 -                        tree.arg.type = syms.stringType;
  10.262 -                    }
  10.263                  }
  10.264              }
  10.265          }
  10.266 @@ -3051,18 +3066,6 @@
  10.267                  Type ctype = cfolder.fold2(opc, left, right);
  10.268                  if (ctype != null) {
  10.269                      owntype = cfolder.coerce(ctype, owntype);
  10.270 -
  10.271 -                    // Remove constant types from arguments to
  10.272 -                    // conserve space. The parser will fold concatenations
  10.273 -                    // of string literals; the code here also
  10.274 -                    // gets rid of intermediate results when some of the
  10.275 -                    // operands are constant identifiers.
  10.276 -                    if (tree.lhs.type.tsym == syms.stringType.tsym) {
  10.277 -                        tree.lhs.type = syms.stringType;
  10.278 -                    }
  10.279 -                    if (tree.rhs.type.tsym == syms.stringType.tsym) {
  10.280 -                        tree.rhs.type = syms.stringType;
  10.281 -                    }
  10.282                  }
  10.283              }
  10.284  
  10.285 @@ -3210,6 +3213,11 @@
  10.286              while (env1.outer != null && !rs.isAccessible(env, env1.enclClass.sym.type, sym))
  10.287                  env1 = env1.outer;
  10.288          }
  10.289 +
  10.290 +        if (env.info.isSerializable) {
  10.291 +            chk.checkElemAccessFromSerializableLambda(tree);
  10.292 +        }
  10.293 +
  10.294          result = checkId(tree, env1.enclClass.sym.type, sym, env, resultInfo);
  10.295      }
  10.296  
  10.297 @@ -3334,6 +3342,10 @@
  10.298              }
  10.299          }
  10.300  
  10.301 +        if (env.info.isSerializable) {
  10.302 +            chk.checkElemAccessFromSerializableLambda(tree);
  10.303 +        }
  10.304 +
  10.305          env.info.selectSuper = selectSuperPrev;
  10.306          result = checkId(tree, site, sym, env, resultInfo);
  10.307      }
  10.308 @@ -4212,6 +4224,11 @@
  10.309                      ((c.flags_field & (Flags.ENUM | Flags.COMPOUND)) == 0)) {
  10.310                      log.error(env.tree.pos(), "enum.types.not.extensible");
  10.311                  }
  10.312 +
  10.313 +                if (isSerializable(c.type)) {
  10.314 +                    env.info.isSerializable = true;
  10.315 +                }
  10.316 +
  10.317                  attribClassBody(env, c);
  10.318  
  10.319                  chk.checkDeprecatedAnnotation(env.tree.pos(), c);
  10.320 @@ -4325,7 +4342,7 @@
  10.321  
  10.322          // Check for proper use of serialVersionUID
  10.323          if (env.info.lint.isEnabled(LintCategory.SERIAL) &&
  10.324 -            isSerializable(c) &&
  10.325 +            isSerializable(c.type) &&
  10.326              (c.flags() & Flags.ENUM) == 0 &&
  10.327              checkForSerial(c)) {
  10.328              checkSerialVersionUID(tree, c);
  10.329 @@ -4365,15 +4382,15 @@
  10.330              return null;
  10.331          }
  10.332  
  10.333 -        /** check if a class is a subtype of Serializable, if that is available. */
  10.334 -        private boolean isSerializable(ClassSymbol c) {
  10.335 +        /** check if a type is a subtype of Serializable, if that is available. */
  10.336 +        boolean isSerializable(Type t) {
  10.337              try {
  10.338                  syms.serializableType.complete();
  10.339              }
  10.340              catch (CompletionFailure e) {
  10.341                  return false;
  10.342              }
  10.343 -            return types.isSubtype(c.type, syms.serializableType);
  10.344 +            return types.isSubtype(t, syms.serializableType);
  10.345          }
  10.346  
  10.347          /** Check that an appropriate serialVersionUID member is defined. */
  10.348 @@ -4653,10 +4670,19 @@
  10.349  
  10.350          private void initTypeIfNeeded(JCTree that) {
  10.351              if (that.type == null) {
  10.352 -                that.type = syms.unknownType;
  10.353 +                if (that.hasTag(METHODDEF)) {
  10.354 +                    that.type = dummyMethodType();
  10.355 +                } else {
  10.356 +                    that.type = syms.unknownType;
  10.357 +                }
  10.358              }
  10.359          }
  10.360  
  10.361 +        private Type dummyMethodType() {
  10.362 +            return new MethodType(List.<Type>nil(), syms.unknownType,
  10.363 +                            List.<Type>nil(), syms.methodClass);
  10.364 +        }
  10.365 +
  10.366          @Override
  10.367          public void scan(JCTree tree) {
  10.368              if (tree == null) return;
  10.369 @@ -4712,7 +4738,8 @@
  10.370          @Override
  10.371          public void visitNewClass(JCNewClass that) {
  10.372              if (that.constructor == null) {
  10.373 -                that.constructor = new MethodSymbol(0, names.init, syms.unknownType, syms.noSymbol);
  10.374 +                that.constructor = new MethodSymbol(0, names.init,
  10.375 +                        dummyMethodType(), syms.noSymbol);
  10.376              }
  10.377              if (that.constructorType == null) {
  10.378                  that.constructorType = syms.unknownType;
  10.379 @@ -4722,22 +4749,28 @@
  10.380  
  10.381          @Override
  10.382          public void visitAssignop(JCAssignOp that) {
  10.383 -            if (that.operator == null)
  10.384 -                that.operator = new OperatorSymbol(names.empty, syms.unknownType, -1, syms.noSymbol);
  10.385 +            if (that.operator == null) {
  10.386 +                that.operator = new OperatorSymbol(names.empty, dummyMethodType(),
  10.387 +                        -1, syms.noSymbol);
  10.388 +            }
  10.389              super.visitAssignop(that);
  10.390          }
  10.391  
  10.392          @Override
  10.393          public void visitBinary(JCBinary that) {
  10.394 -            if (that.operator == null)
  10.395 -                that.operator = new OperatorSymbol(names.empty, syms.unknownType, -1, syms.noSymbol);
  10.396 +            if (that.operator == null) {
  10.397 +                that.operator = new OperatorSymbol(names.empty, dummyMethodType(),
  10.398 +                        -1, syms.noSymbol);
  10.399 +            }
  10.400              super.visitBinary(that);
  10.401          }
  10.402  
  10.403          @Override
  10.404          public void visitUnary(JCUnary that) {
  10.405 -            if (that.operator == null)
  10.406 -                that.operator = new OperatorSymbol(names.empty, syms.unknownType, -1, syms.noSymbol);
  10.407 +            if (that.operator == null) {
  10.408 +                that.operator = new OperatorSymbol(names.empty, dummyMethodType(),
  10.409 +                        -1, syms.noSymbol);
  10.410 +            }
  10.411              super.visitUnary(that);
  10.412          }
  10.413  
  10.414 @@ -4753,7 +4786,8 @@
  10.415          public void visitReference(JCMemberReference that) {
  10.416              super.visitReference(that);
  10.417              if (that.sym == null) {
  10.418 -                that.sym = new MethodSymbol(0, names.empty, syms.unknownType, syms.noSymbol);
  10.419 +                that.sym = new MethodSymbol(0, names.empty, dummyMethodType(),
  10.420 +                        syms.noSymbol);
  10.421              }
  10.422              if (that.targets == null) {
  10.423                  that.targets = List.nil();

    11.1 --- a/src/share/classes/com/sun/tools/javac/comp/AttrContext.java	Mon May 19 22:00:11 2014 -0700
    11.2 +++ b/src/share/classes/com/sun/tools/javac/comp/AttrContext.java	Thu May 29 13:46:36 2014 -0700
    11.3 @@ -1,5 +1,5 @@
    11.4  /*
    11.5 - * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
    11.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    11.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    11.8   *
    11.9   * This code is free software; you can redistribute it and/or modify it
   11.10 @@ -54,6 +54,10 @@
   11.11       */
   11.12      boolean selectSuper = false;
   11.13  
   11.14 +    /** Is the current target of lambda expression or method reference serializable?
   11.15 +     */
   11.16 +    boolean isSerializable = false;
   11.17 +
   11.18      /** Are arguments to current function applications boxed into an array for varargs?
   11.19       */
   11.20      Resolve.MethodResolutionPhase pendingResolutionPhase = null;
   11.21 @@ -89,6 +93,7 @@
   11.22          info.enclVar = enclVar;
   11.23          info.returnResult = returnResult;
   11.24          info.defaultSuperCallSite = defaultSuperCallSite;
   11.25 +        info.isSerializable = isSerializable;
   11.26          return info;
   11.27      }
   11.28  

    12.1 --- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Mon May 19 22:00:11 2014 -0700
    12.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Thu May 29 13:46:36 2014 -0700
    12.3 @@ -1,5 +1,5 @@
    12.4  /*
    12.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    12.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    12.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    12.8   *
    12.9   * This code is free software; you can redistribute it and/or modify it
   12.10 @@ -82,6 +82,7 @@
   12.11      private final TreeInfo treeinfo;
   12.12      private final JavaFileManager fileManager;
   12.13      private final Profile profile;
   12.14 +    private final boolean warnOnAccessToSensitiveMembers;
   12.15  
   12.16      // The set of lint options currently in effect. It is initialized
   12.17      // from the context, and then is set/reset as needed by Attr as it
   12.18 @@ -131,6 +132,7 @@
   12.19          warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
   12.20          suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
   12.21          enableSunApiLintControl = options.isSet("enableSunApiLintControl");
   12.22 +        warnOnAccessToSensitiveMembers = options.isSet("warnOnAccessToSensitiveMembers");
   12.23  
   12.24          Target target = Target.instance(context);
   12.25          syntheticNameChar = target.syntheticNameChar();
   12.26 @@ -510,6 +512,11 @@
   12.27          public DeferredAttrContext deferredAttrContext() {
   12.28              return deferredAttr.emptyDeferredAttrContext;
   12.29          }
   12.30 +
   12.31 +        @Override
   12.32 +        public String toString() {
   12.33 +            return "CheckContext: basicHandler";
   12.34 +        }
   12.35      };
   12.36  
   12.37      /** Check that a given type is assignable to a given proto-type.
   12.38 @@ -616,7 +623,7 @@
   12.39           } else if (a.isExtendsBound()) {
   12.40               return types.isCastable(bound, types.upperBound(a), types.noWarnings);
   12.41           } else if (a.isSuperBound()) {
   12.42 -             return !types.notSoftSubtype(types.lowerBound(a), bound);
   12.43 +             return !types.notSoftSubtype(types.wildLowerBound(a), bound);
   12.44           }
   12.45           return true;
   12.46       }
   12.47 @@ -2583,6 +2590,44 @@
   12.48          }
   12.49      }
   12.50  
   12.51 +    void checkElemAccessFromSerializableLambda(final JCTree tree) {
   12.52 +        if (warnOnAccessToSensitiveMembers) {
   12.53 +            Symbol sym = TreeInfo.symbol(tree);
   12.54 +            if ((sym.kind & (VAR | MTH)) == 0) {
   12.55 +                return;
   12.56 +            }
   12.57 +
   12.58 +            if (sym.kind == VAR) {
   12.59 +                if ((sym.flags() & PARAMETER) != 0 ||
   12.60 +                    sym.isLocal() ||
   12.61 +                    sym.name == names._this ||
   12.62 +                    sym.name == names._super) {
   12.63 +                    return;
   12.64 +                }
   12.65 +            }
   12.66 +
   12.67 +            if (!types.isSubtype(sym.owner.type, syms.serializableType) &&
   12.68 +                    isEffectivelyNonPublic(sym)) {
   12.69 +                log.warning(tree.pos(),
   12.70 +                        "access.to.sensitive.member.from.serializable.element", sym);
   12.71 +            }
   12.72 +        }
   12.73 +    }
   12.74 +
   12.75 +    private boolean isEffectivelyNonPublic(Symbol sym) {
   12.76 +        if (sym.packge() == syms.rootPackage) {
   12.77 +            return false;
   12.78 +        }
   12.79 +
   12.80 +        while (sym.kind != Kinds.PCK) {
   12.81 +            if ((sym.flags() & PUBLIC) == 0) {
   12.82 +                return true;
   12.83 +            }
   12.84 +            sym = sym.owner;
   12.85 +        }
   12.86 +        return false;
   12.87 +    }
   12.88 +
   12.89      /** Report a conflict between a user symbol and a synthetic symbol.
   12.90       */
   12.91      private void syntheticError(DiagnosticPosition pos, Symbol sym) {
   12.92 @@ -2680,7 +2725,7 @@
   12.93          if (types.isSameType(type, syms.stringType)) return;
   12.94          if ((type.tsym.flags() & Flags.ENUM) != 0) return;
   12.95          if ((type.tsym.flags() & Flags.ANNOTATION) != 0) return;
   12.96 -        if (types.lowerBound(type).tsym == syms.classType.tsym) return;
   12.97 +        if (types.cvarLowerBound(type).tsym == syms.classType.tsym) return;
   12.98          if (types.isArray(type) && !types.isArray(types.elemtype(type))) {
   12.99              validateAnnotationType(pos, types.elemtype(type));
  12.100              return;
  12.101 @@ -2779,7 +2824,7 @@
  12.102          validateDocumented(t.tsym, s, pos);
  12.103          validateInherited(t.tsym, s, pos);
  12.104          validateTarget(t.tsym, s, pos);
  12.105 -        validateDefault(t.tsym, s, pos);
  12.106 +        validateDefault(t.tsym, pos);
  12.107      }
  12.108  
  12.109      private void validateValue(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
  12.110 @@ -2898,7 +2943,9 @@
  12.111  
  12.112  
  12.113      /** Checks that s is a subset of t, with respect to ElementType
  12.114 -     * semantics, specifically {ANNOTATION_TYPE} is a subset of {TYPE}
  12.115 +     * semantics, specifically {ANNOTATION_TYPE} is a subset of {TYPE},
  12.116 +     * and {TYPE_USE} covers the set {ANNOTATION_TYPE, TYPE, TYPE_USE,
  12.117 +     * TYPE_PARAMETER}.
  12.118       */
  12.119      private boolean isTargetSubsetOf(Set<Name> s, Set<Name> t) {
  12.120          // Check that all elements in s are present in t
  12.121 @@ -2911,6 +2958,12 @@
  12.122                  } else if (n1 == names.TYPE && n2 == names.ANNOTATION_TYPE) {
  12.123                      currentElementOk = true;
  12.124                      break;
  12.125 +                } else if (n1 == names.TYPE_USE &&
  12.126 +                        (n2 == names.TYPE ||
  12.127 +                         n2 == names.ANNOTATION_TYPE ||
  12.128 +                         n2 == names.TYPE_PARAMETER)) {
  12.129 +                    currentElementOk = true;
  12.130 +                    break;
  12.131                  }
  12.132              }
  12.133              if (!currentElementOk)
  12.134 @@ -2919,7 +2972,7 @@
  12.135          return true;
  12.136      }
  12.137  
  12.138 -    private void validateDefault(Symbol container, Symbol contained, DiagnosticPosition pos) {
  12.139 +    private void validateDefault(Symbol container, DiagnosticPosition pos) {
  12.140          // validate that all other elements of containing type has defaults
  12.141          Scope scope = container.members();
  12.142          for(Symbol elm : scope.getElements()) {

    13.1 --- a/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Mon May 19 22:00:11 2014 -0700
    13.2 +++ b/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Thu May 29 13:46:36 2014 -0700
    13.3 @@ -1,5 +1,5 @@
    13.4  /*
    13.5 - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
    13.6 + * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
    13.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.8   *
    13.9   * This code is free software; you can redistribute it and/or modify it
   13.10 @@ -25,7 +25,7 @@
   13.11  
   13.12  package com.sun.tools.javac.comp;
   13.13  
   13.14 -import com.sun.source.tree.MemberReferenceTree;
   13.15 +import com.sun.source.tree.LambdaExpressionTree.BodyKind;
   13.16  import com.sun.tools.javac.code.*;
   13.17  import com.sun.tools.javac.tree.*;
   13.18  import com.sun.tools.javac.util.*;
   13.19 @@ -35,10 +35,8 @@
   13.20  import com.sun.tools.javac.comp.Attr.ResultInfo;
   13.21  import com.sun.tools.javac.comp.Infer.InferenceContext;
   13.22  import com.sun.tools.javac.comp.Resolve.MethodResolutionPhase;
   13.23 -import com.sun.tools.javac.comp.Resolve.ReferenceLookupHelper;
   13.24  import com.sun.tools.javac.tree.JCTree.*;
   13.25  
   13.26 -
   13.27  import java.util.ArrayList;
   13.28  import java.util.Collections;
   13.29  import java.util.EnumSet;
   13.30 @@ -48,6 +46,7 @@
   13.31  import java.util.Set;
   13.32  import java.util.WeakHashMap;
   13.33  
   13.34 +import static com.sun.tools.javac.code.Kinds.VAL;
   13.35  import static com.sun.tools.javac.code.TypeTag.*;
   13.36  import static com.sun.tools.javac.tree.JCTree.Tag.*;
   13.37  
   13.38 @@ -76,6 +75,8 @@
   13.39      final Symtab syms;
   13.40      final TreeMaker make;
   13.41      final Types types;
   13.42 +    final Flow flow;
   13.43 +    final Names names;
   13.44  
   13.45      public static DeferredAttr instance(Context context) {
   13.46          DeferredAttr instance = context.get(deferredAttrKey);
   13.47 @@ -96,7 +97,8 @@
   13.48          syms = Symtab.instance(context);
   13.49          make = TreeMaker.instance(context);
   13.50          types = Types.instance(context);
   13.51 -        Names names = Names.instance(context);
   13.52 +        flow = Flow.instance(context);
   13.53 +        names = Names.instance(context);
   13.54          stuckTree = make.Ident(names.empty).setType(Type.stuckType);
   13.55          emptyDeferredAttrContext =
   13.56              new DeferredAttrContext(AttrMode.CHECK, null, MethodResolutionPhase.BOX, infer.emptyContext, null, null) {
   13.57 @@ -108,6 +110,11 @@
   13.58                  void complete() {
   13.59                      Assert.error("Empty deferred context!");
   13.60                  }
   13.61 +
   13.62 +                @Override
   13.63 +                public String toString() {
   13.64 +                    return "Empty deferred context!";
   13.65 +                }
   13.66              };
   13.67      }
   13.68  
   13.69 @@ -139,6 +146,11 @@
   13.70              return DEFERRED;
   13.71          }
   13.72  
   13.73 +        @Override
   13.74 +        public String toString() {
   13.75 +            return "DeferredType";
   13.76 +        }
   13.77 +
   13.78          /**
   13.79           * A speculative cache is used to keep track of all overload resolution rounds
   13.80           * that triggered speculative attribution on a given deferred type. Each entry
   13.81 @@ -378,7 +390,9 @@
   13.82          }
   13.83      }
   13.84      //where
   13.85 -        protected TreeScanner unenterScanner = new TreeScanner() {
   13.86 +        protected UnenterScanner unenterScanner = new UnenterScanner();
   13.87 +
   13.88 +        class UnenterScanner extends TreeScanner {
   13.89              @Override
   13.90              public void visitClassDef(JCClassDecl tree) {
   13.91                  ClassSymbol csym = tree.sym;
   13.92 @@ -391,7 +405,7 @@
   13.93                  syms.classes.remove(csym.flatname);
   13.94                  super.visitClassDef(tree);
   13.95              }
   13.96 -        };
   13.97 +        }
   13.98  
   13.99      /**
  13.100       * A deferred context is created on each method check. A deferred context is
  13.101 @@ -595,19 +609,111 @@
  13.102              public void visitLambda(JCLambda tree) {
  13.103                  Check.CheckContext checkContext = resultInfo.checkContext;
  13.104                  Type pt = resultInfo.pt;
  13.105 -                if (inferenceContext.inferencevars.contains(pt)) {
  13.106 -                    //ok
  13.107 -                    return;
  13.108 -                } else {
  13.109 +                if (!inferenceContext.inferencevars.contains(pt)) {
  13.110                      //must be a functional descriptor
  13.111 +                    Type descriptorType = null;
  13.112                      try {
  13.113 -                        Type desc = types.findDescriptorType(pt);
  13.114 -                        if (desc.getParameterTypes().length() != tree.params.length()) {
  13.115 -                            checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
  13.116 -                        }
  13.117 +                        descriptorType = types.findDescriptorType(pt);
  13.118                      } catch (Types.FunctionDescriptorLookupError ex) {
  13.119                          checkContext.report(null, ex.getDiagnostic());
  13.120                      }
  13.121 +
  13.122 +                    if (descriptorType.getParameterTypes().length() != tree.params.length()) {
  13.123 +                        checkContext.report(tree,
  13.124 +                                diags.fragment("incompatible.arg.types.in.lambda"));
  13.125 +                    }
  13.126 +
  13.127 +                    Type currentReturnType = descriptorType.getReturnType();
  13.128 +                    boolean returnTypeIsVoid = currentReturnType.hasTag(VOID);
  13.129 +                    if (tree.getBodyKind() == BodyKind.EXPRESSION) {
  13.130 +                        boolean isExpressionCompatible = !returnTypeIsVoid ||
  13.131 +                            TreeInfo.isExpressionStatement((JCExpression)tree.getBody());
  13.132 +                        if (!isExpressionCompatible) {
  13.133 +                            resultInfo.checkContext.report(tree.pos(),
  13.134 +                                diags.fragment("incompatible.ret.type.in.lambda",
  13.135 +                                    diags.fragment("missing.ret.val", currentReturnType)));
  13.136 +                        }
  13.137 +                    } else {
  13.138 +                        LambdaBodyStructChecker lambdaBodyChecker =
  13.139 +                                new LambdaBodyStructChecker();
  13.140 +
  13.141 +                        tree.body.accept(lambdaBodyChecker);
  13.142 +                        boolean isVoidCompatible = lambdaBodyChecker.isVoidCompatible;
  13.143 +
  13.144 +                        if (returnTypeIsVoid) {
  13.145 +                            if (!isVoidCompatible) {
  13.146 +                                resultInfo.checkContext.report(tree.pos(),
  13.147 +                                    diags.fragment("unexpected.ret.val"));
  13.148 +                            }
  13.149 +                        } else {
  13.150 +                            boolean isValueCompatible = lambdaBodyChecker.isPotentiallyValueCompatible
  13.151 +                                && !canLambdaBodyCompleteNormally(tree);
  13.152 +                            if (!isValueCompatible && !isVoidCompatible) {
  13.153 +                                log.error(tree.body.pos(),
  13.154 +                                    "lambda.body.neither.value.nor.void.compatible");
  13.155 +                            }
  13.156 +
  13.157 +                            if (!isValueCompatible) {
  13.158 +                                resultInfo.checkContext.report(tree.pos(),
  13.159 +                                    diags.fragment("incompatible.ret.type.in.lambda",
  13.160 +                                        diags.fragment("missing.ret.val", currentReturnType)));
  13.161 +                            }
  13.162 +                        }
  13.163 +                    }
  13.164 +                }
  13.165 +            }
  13.166 +
  13.167 +            boolean canLambdaBodyCompleteNormally(JCLambda tree) {
  13.168 +                JCLambda newTree = new TreeCopier<>(make).copy(tree);
  13.169 +                /* attr.lambdaEnv will create a meaningful env for the
  13.170 +                 * lambda expression. This is specially useful when the
  13.171 +                 * lambda is used as the init of a field. But we need to
  13.172 +                 * remove any added symbol.
  13.173 +                 */
  13.174 +                Env<AttrContext> localEnv = attr.lambdaEnv(newTree, env);
  13.175 +                try {
  13.176 +                    List<JCVariableDecl> tmpParams = newTree.params;
  13.177 +                    while (tmpParams.nonEmpty()) {
  13.178 +                        tmpParams.head.vartype = make.at(tmpParams.head).Type(syms.errType);
  13.179 +                        tmpParams = tmpParams.tail;
  13.180 +                    }
  13.181 +
  13.182 +                    attr.attribStats(newTree.params, localEnv);
  13.183 +
  13.184 +                    /* set pt to Type.noType to avoid generating any bound
  13.185 +                     * which may happen if lambda's return type is an
  13.186 +                     * inference variable
  13.187 +                     */
  13.188 +                    Attr.ResultInfo bodyResultInfo = attr.new ResultInfo(VAL, Type.noType);
  13.189 +                    localEnv.info.returnResult = bodyResultInfo;
  13.190 +
  13.191 +                    // discard any log output
  13.192 +                    Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
  13.193 +                    try {
  13.194 +                        JCBlock body = (JCBlock)newTree.body;
  13.195 +                        /* we need to attribute the lambda body before
  13.196 +                         * doing the aliveness analysis. This is because
  13.197 +                         * constant folding occurs during attribution
  13.198 +                         * and the reachability of some statements depends
  13.199 +                         * on constant values, for example:
  13.200 +                         *
  13.201 +                         *     while (true) {...}
  13.202 +                         */
  13.203 +                        attr.attribStats(body.stats, localEnv);
  13.204 +
  13.205 +                        attr.preFlow(newTree);
  13.206 +                        /* make an aliveness / reachability analysis of the lambda
  13.207 +                         * to determine if it can complete normally
  13.208 +                         */
  13.209 +                        flow.analyzeLambda(localEnv, newTree, make, true);
  13.210 +                    } finally {
  13.211 +                        log.popDiagnosticHandler(diagHandler);
  13.212 +                    }
  13.213 +                    return newTree.canCompleteNormally;
  13.214 +                } finally {
  13.215 +                    JCBlock body = (JCBlock)newTree.body;
  13.216 +                    unenterScanner.scan(body.stats);
  13.217 +                    localEnv.info.scope.leave();
  13.218                  }
  13.219              }
  13.220  
  13.221 @@ -625,10 +731,7 @@
  13.222              public void visitReference(JCMemberReference tree) {
  13.223                  Check.CheckContext checkContext = resultInfo.checkContext;
  13.224                  Type pt = resultInfo.pt;
  13.225 -                if (inferenceContext.inferencevars.contains(pt)) {
  13.226 -                    //ok
  13.227 -                    return;
  13.228 -                } else {
  13.229 +                if (!inferenceContext.inferencevars.contains(pt)) {
  13.230                      try {
  13.231                          types.findDescriptorType(pt);
  13.232                      } catch (Types.FunctionDescriptorLookupError ex) {
  13.233 @@ -658,6 +761,40 @@
  13.234                  }
  13.235              }
  13.236          }
  13.237 +
  13.238 +        /* This visitor looks for return statements, its analysis will determine if
  13.239 +         * a lambda body is void or value compatible. We must analyze return
  13.240 +         * statements contained in the lambda body only, thus any return statement
  13.241 +         * contained in an inner class or inner lambda body, should be ignored.
  13.242 +         */
  13.243 +        class LambdaBodyStructChecker extends TreeScanner {
  13.244 +            boolean isVoidCompatible = true;
  13.245 +            boolean isPotentiallyValueCompatible = true;
  13.246 +
  13.247 +            @Override
  13.248 +            public void visitClassDef(JCClassDecl tree) {
  13.249 +                // do nothing
  13.250 +            }
  13.251 +
  13.252 +            @Override
  13.253 +            public void visitLambda(JCLambda tree) {
  13.254 +                // do nothing
  13.255 +            }
  13.256 +
  13.257 +            @Override
  13.258 +            public void visitNewClass(JCNewClass tree) {
  13.259 +                // do nothing
  13.260 +            }
  13.261 +
  13.262 +            @Override
  13.263 +            public void visitReturn(JCReturn tree) {
  13.264 +                if (tree.expr != null) {
  13.265 +                    isVoidCompatible = false;
  13.266 +                } else {
  13.267 +                    isPotentiallyValueCompatible = false;
  13.268 +                }
  13.269 +            }
  13.270 +        }
  13.271      }
  13.272  
  13.273      /** an empty deferred attribution context - all methods throw exceptions */
  13.274 @@ -769,7 +906,7 @@
  13.275          /**
  13.276           * handler that is executed when a node has been discarded
  13.277           */
  13.278 -        abstract void skip(JCTree tree);
  13.279 +        void skip(JCTree tree) {}
  13.280      }
  13.281  
  13.282      /**
  13.283 @@ -781,11 +918,6 @@
  13.284          PolyScanner() {
  13.285              super(EnumSet.of(CONDEXPR, PARENS, LAMBDA, REFERENCE));
  13.286          }
  13.287 -
  13.288 -        @Override
  13.289 -        void skip(JCTree tree) {
  13.290 -            //do nothing
  13.291 -        }
  13.292      }
  13.293  
  13.294      /**
  13.295 @@ -798,11 +930,6 @@
  13.296              super(EnumSet.of(BLOCK, CASE, CATCH, DOLOOP, FOREACHLOOP,
  13.297                      FORLOOP, RETURN, SYNCHRONIZED, SWITCH, TRY, WHILELOOP));
  13.298          }
  13.299 -
  13.300 -        @Override
  13.301 -        void skip(JCTree tree) {
  13.302 -            //do nothing
  13.303 -        }
  13.304      }
  13.305  
  13.306      /**

    14.1 --- a/src/share/classes/com/sun/tools/javac/comp/Flow.java	Mon May 19 22:00:11 2014 -0700
    14.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Flow.java	Thu May 29 13:46:36 2014 -0700
    14.3 @@ -1,5 +1,5 @@
    14.4  /*
    14.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    14.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    14.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    14.8   *
    14.9   * This code is free software; you can redistribute it and/or modify it
   14.10 @@ -45,7 +45,7 @@
   14.11  import static com.sun.tools.javac.tree.JCTree.Tag.*;
   14.12  
   14.13  /** This pass implements dataflow analysis for Java programs though
   14.14 - *  different AST visitor steps. Liveness analysis (see AliveAlanyzer) checks that
   14.15 + *  different AST visitor steps. Liveness analysis (see AliveAnalyzer) checks that
   14.16   *  every statement is reachable. Exception analysis (see FlowAnalyzer) ensures that
   14.17   *  every checked exception that is thrown is declared or caught.  Definite assignment analysis
   14.18   *  (see AssignAnalyzer) ensures that each variable is assigned when used.  Definite
   14.19 @@ -197,6 +197,7 @@
   14.20      private final boolean allowImprovedRethrowAnalysis;
   14.21      private final boolean allowImprovedCatchAnalysis;
   14.22      private final boolean allowEffectivelyFinalInInnerClasses;
   14.23 +    private final boolean enforceThisDotInit;
   14.24  
   14.25      public static Flow instance(Context context) {
   14.26          Flow instance = context.get(flowKey);
   14.27 @@ -207,7 +208,7 @@
   14.28  
   14.29      public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
   14.30          new AliveAnalyzer().analyzeTree(env, make);
   14.31 -        new AssignAnalyzer(log, syms, lint, names).analyzeTree(env);
   14.32 +        new AssignAnalyzer(log, syms, lint, names, enforceThisDotInit).analyzeTree(env);
   14.33          new FlowAnalyzer().analyzeTree(env, make);
   14.34          new CaptureAnalyzer().analyzeTree(env, make);
   14.35      }
   14.36 @@ -239,7 +240,7 @@
   14.37          //related errors, which will allow for more errors to be detected
   14.38          Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
   14.39          try {
   14.40 -            new AssignAnalyzer(log, syms, lint, names).analyzeTree(env);
   14.41 +            new AssignAnalyzer(log, syms, lint, names, enforceThisDotInit).analyzeTree(env);
   14.42              LambdaFlowAnalyzer flowAnalyzer = new LambdaFlowAnalyzer();
   14.43              flowAnalyzer.analyzeTree(env, that, make);
   14.44              return flowAnalyzer.inferredThrownTypes;
   14.45 @@ -289,6 +290,7 @@
   14.46          allowImprovedRethrowAnalysis = source.allowImprovedRethrowAnalysis();
   14.47          allowImprovedCatchAnalysis = source.allowImprovedCatchAnalysis();
   14.48          allowEffectivelyFinalInInnerClasses = source.allowEffectivelyFinalInInnerClasses();
   14.49 +        enforceThisDotInit = source.enforceThisDotInit();
   14.50      }
   14.51  
   14.52      /**
   14.53 @@ -1427,6 +1429,8 @@
   14.54  
   14.55          protected Names names;
   14.56  
   14.57 +        final boolean enforceThisDotInit;
   14.58 +
   14.59          public static class AbstractAssignPendingExit extends BaseAnalyzer.PendingExit {
   14.60  
   14.61              final Bits inits;
   14.62 @@ -1449,7 +1453,7 @@
   14.63              }
   14.64          }
   14.65  
   14.66 -        public AbstractAssignAnalyzer(Bits inits, Symtab syms, Names names) {
   14.67 +        public AbstractAssignAnalyzer(Bits inits, Symtab syms, Names names, boolean enforceThisDotInit) {
   14.68              this.inits = inits;
   14.69              uninits = new Bits();
   14.70              uninitsTry = new Bits();
   14.71 @@ -1459,11 +1463,22 @@
   14.72              uninitsWhenFalse = new Bits(true);
   14.73              this.syms = syms;
   14.74              this.names = names;
   14.75 +            this.enforceThisDotInit = enforceThisDotInit;
   14.76          }
   14.77  
   14.78 +        private boolean isInitialConstructor = false;
   14.79 +
   14.80          @Override
   14.81          protected void markDead(JCTree tree) {
   14.82 -            inits.inclRange(returnadr, nextadr);
   14.83 +            if (!isInitialConstructor) {
   14.84 +                inits.inclRange(returnadr, nextadr);
   14.85 +            } else {
   14.86 +                for (int address = returnadr; address < nextadr; address++) {
   14.87 +                    if (!(isFinalUninitializedStaticField(vardecls[address].sym))) {
   14.88 +                        inits.incl(address);
   14.89 +                    }
   14.90 +                }
   14.91 +            }
   14.92              uninits.inclRange(returnadr, nextadr);
   14.93          }
   14.94  
   14.95 @@ -1476,8 +1491,17 @@
   14.96              return
   14.97                  sym.pos >= startPos &&
   14.98                  ((sym.owner.kind == MTH ||
   14.99 -                 ((sym.flags() & (FINAL | HASINIT | PARAMETER)) == FINAL &&
  14.100 -                  classDef.sym.isEnclosedBy((ClassSymbol)sym.owner))));
  14.101 +                isFinalUninitializedField(sym)));
  14.102 +        }
  14.103 +
  14.104 +        boolean isFinalUninitializedField(VarSymbol sym) {
  14.105 +            return sym.owner.kind == TYP &&
  14.106 +                   ((sym.flags() & (FINAL | HASINIT | PARAMETER)) == FINAL &&
  14.107 +                   classDef.sym.isEnclosedBy((ClassSymbol)sym.owner));
  14.108 +        }
  14.109 +
  14.110 +        boolean isFinalUninitializedStaticField(VarSymbol sym) {
  14.111 +            return isFinalUninitializedField(sym) && sym.isStatic();
  14.112          }
  14.113  
  14.114          /** Initialize new trackable variable by setting its address field
  14.115 @@ -1731,10 +1755,9 @@
  14.116              int returnadrPrev = returnadr;
  14.117  
  14.118              Assert.check(pendingExits.isEmpty());
  14.119 -
  14.120 +            boolean lastInitialConstructor = isInitialConstructor;
  14.121              try {
  14.122 -                boolean isInitialConstructor =
  14.123 -                    TreeInfo.isInitialConstructor(tree);
  14.124 +                isInitialConstructor = TreeInfo.isInitialConstructor(tree);
  14.125  
  14.126                  if (!isInitialConstructor) {
  14.127                      firstadr = nextadr;
  14.128 @@ -1789,6 +1812,7 @@
  14.129                  nextadr = nextadrPrev;
  14.130                  firstadr = firstadrPrev;
  14.131                  returnadr = returnadrPrev;
  14.132 +                isInitialConstructor = lastInitialConstructor;
  14.133              }
  14.134          }
  14.135  
  14.136 @@ -2261,12 +2285,34 @@
  14.137  
  14.138          public void visitAssign(JCAssign tree) {
  14.139              JCTree lhs = TreeInfo.skipParens(tree.lhs);
  14.140 -            if (!(lhs instanceof JCIdent)) {
  14.141 +            if (!isIdentOrThisDotIdent(lhs))
  14.142                  scanExpr(lhs);
  14.143 -            }
  14.144              scanExpr(tree.rhs);
  14.145              letInit(lhs);
  14.146          }
  14.147 +        private boolean isIdentOrThisDotIdent(JCTree lhs) {
  14.148 +            if (lhs.hasTag(IDENT))
  14.149 +                return true;
  14.150 +            if (!lhs.hasTag(SELECT))
  14.151 +                return false;
  14.152 +
  14.153 +            JCFieldAccess fa = (JCFieldAccess)lhs;
  14.154 +            return fa.selected.hasTag(IDENT) &&
  14.155 +                   ((JCIdent)fa.selected).name == names._this;
  14.156 +        }
  14.157 +
  14.158 +        // check fields accessed through this.<field> are definitely
  14.159 +        // assigned before reading their value
  14.160 +        public void visitSelect(JCFieldAccess tree) {
  14.161 +            super.visitSelect(tree);
  14.162 +            if (enforceThisDotInit &&
  14.163 +                tree.selected.hasTag(IDENT) &&
  14.164 +                ((JCIdent)tree.selected).name == names._this &&
  14.165 +                tree.sym.kind == VAR)
  14.166 +            {
  14.167 +                checkInit(tree.pos(), (VarSymbol)tree.sym);
  14.168 +            }
  14.169 +        }
  14.170  
  14.171          public void visitAssignop(JCAssignOp tree) {
  14.172              scanExpr(tree.lhs);
  14.173 @@ -2400,8 +2446,8 @@
  14.174              }
  14.175          }
  14.176  
  14.177 -        public AssignAnalyzer(Log log, Symtab syms, Lint lint, Names names) {
  14.178 -            super(new Bits(), syms, names);
  14.179 +        public AssignAnalyzer(Log log, Symtab syms, Lint lint, Names names, boolean enforceThisDotInit) {
  14.180 +            super(new Bits(), syms, names, enforceThisDotInit);
  14.181              this.log = log;
  14.182              this.lint = lint;
  14.183          }

    15.1 --- a/src/share/classes/com/sun/tools/javac/comp/Infer.java	Mon May 19 22:00:11 2014 -0700
    15.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Infer.java	Thu May 29 13:46:36 2014 -0700
    15.3 @@ -1,5 +1,5 @@
    15.4  /*
    15.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    15.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    15.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    15.8   *
    15.9   * This code is free software; you can redistribute it and/or modify it
   15.10 @@ -142,24 +142,24 @@
   15.11       * Main inference entry point - instantiate a generic method type
   15.12       * using given argument types and (possibly) an expected target-type.
   15.13       */
   15.14 -    public Type instantiateMethod(Env<AttrContext> env,
   15.15 -                                  List<Type> tvars,
   15.16 -                                  MethodType mt,
   15.17 -                                  Attr.ResultInfo resultInfo,
   15.18 -                                  Symbol msym,
   15.19 -                                  List<Type> argtypes,
   15.20 -                                  boolean allowBoxing,
   15.21 -                                  boolean useVarargs,
   15.22 -                                  Resolve.MethodResolutionContext resolveContext,
   15.23 -                                  Warner warn) throws InferenceException {
   15.24 +    Type instantiateMethod( Env<AttrContext> env,
   15.25 +                            List<Type> tvars,
   15.26 +                            MethodType mt,
   15.27 +                            Attr.ResultInfo resultInfo,
   15.28 +                            MethodSymbol msym,
   15.29 +                            List<Type> argtypes,
   15.30 +                            boolean allowBoxing,
   15.31 +                            boolean useVarargs,
   15.32 +                            Resolve.MethodResolutionContext resolveContext,
   15.33 +                            Warner warn) throws InferenceException {
   15.34          //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
   15.35 -        final InferenceContext inferenceContext = new InferenceContext(tvars);
   15.36 +        final InferenceContext inferenceContext = new InferenceContext(tvars);  //B0
   15.37          inferenceException.clear();
   15.38          try {
   15.39              DeferredAttr.DeferredAttrContext deferredAttrContext =
   15.40                          resolveContext.deferredAttrContext(msym, inferenceContext, resultInfo, warn);
   15.41  
   15.42 -            resolveContext.methodCheck.argumentsAcceptable(env, deferredAttrContext,
   15.43 +            resolveContext.methodCheck.argumentsAcceptable(env, deferredAttrContext,   //B2
   15.44                      argtypes, mt.getParameterTypes(), warn);
   15.45  
   15.46              if (allowGraphInference &&
   15.47 @@ -167,7 +167,8 @@
   15.48                      !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
   15.49                  //inject return constraints earlier
   15.50                  checkWithinBounds(inferenceContext, warn); //propagation
   15.51 -                Type newRestype = generateReturnConstraints(resultInfo, mt, inferenceContext);
   15.52 +                Type newRestype = generateReturnConstraints(env.tree, resultInfo,  //B3
   15.53 +                        mt, inferenceContext);
   15.54                  mt = (MethodType)types.createMethodTypeWithReturn(mt, newRestype);
   15.55                  //propagate outwards if needed
   15.56                  if (resultInfo.checkContext.inferenceContext().free(resultInfo.pt)) {
   15.57 @@ -193,7 +194,7 @@
   15.58                      inferenceContext.restvars().nonEmpty() &&
   15.59                      resultInfo != null &&
   15.60                      !warn.hasNonSilentLint(Lint.LintCategory.UNCHECKED)) {
   15.61 -                generateReturnConstraints(resultInfo, mt, inferenceContext);
   15.62 +                generateReturnConstraints(env.tree, resultInfo, mt, inferenceContext);
   15.63                  inferenceContext.solveLegacy(false, warn, LegacyInferenceSteps.EQ_UPPER.steps); //maximizeInst
   15.64                  mt = (MethodType)inferenceContext.asInstType(mt);
   15.65              }
   15.66 @@ -210,6 +211,12 @@
   15.67              } else {
   15.68                  inferenceContext.notifyChange(inferenceContext.boundedVars());
   15.69              }
   15.70 +            if (resultInfo == null) {
   15.71 +                /* if the is no result info then we can clear the capture types
   15.72 +                 * cache without affecting any result info check
   15.73 +                 */
   15.74 +                inferenceContext.captureTypeCache.clear();
   15.75 +            }
   15.76          }
   15.77      }
   15.78  
   15.79 @@ -218,11 +225,12 @@
   15.80       * call occurs in a context where a type T is expected, use the expected
   15.81       * type to derive more constraints on the generic method inference variables.
   15.82       */
   15.83 -    Type generateReturnConstraints(Attr.ResultInfo resultInfo,
   15.84 +    Type generateReturnConstraints(JCTree tree, Attr.ResultInfo resultInfo,
   15.85              MethodType mt, InferenceContext inferenceContext) {
   15.86 +        InferenceContext rsInfoInfContext = resultInfo.checkContext.inferenceContext();
   15.87          Type from = mt.getReturnType();
   15.88          if (mt.getReturnType().containsAny(inferenceContext.inferencevars) &&
   15.89 -                resultInfo.checkContext.inferenceContext() != emptyContext) {
   15.90 +                rsInfoInfContext != emptyContext) {
   15.91              from = types.capture(from);
   15.92              //add synthetic captured ivars
   15.93              for (Type t : from.getTypeArguments()) {
   15.94 @@ -231,13 +239,29 @@
   15.95                  }
   15.96              }
   15.97          }
   15.98 -        Type qtype1 = inferenceContext.asFree(from);
   15.99 -        Type to = returnConstraintTarget(qtype1, resultInfo.pt);
  15.100 -        Assert.check(allowGraphInference || !resultInfo.checkContext.inferenceContext().free(to),
  15.101 +        Type qtype = inferenceContext.asUndetVar(from);
  15.102 +        Type to = resultInfo.pt;
  15.103 +
  15.104 +        if (qtype.hasTag(VOID)) {
  15.105 +            to = syms.voidType;
  15.106 +        } else if (to.hasTag(NONE)) {
  15.107 +            to = from.isPrimitive() ? from : syms.objectType;
  15.108 +        } else if (qtype.hasTag(UNDETVAR)) {
  15.109 +            if (resultInfo.pt.isReference()) {
  15.110 +                to = generateReturnConstraintsUndetVarToReference(
  15.111 +                        tree, (UndetVar)qtype, to, resultInfo, inferenceContext);
  15.112 +            } else {
  15.113 +                if (to.isPrimitive()) {
  15.114 +                    to = generateReturnConstraintsPrimitive(tree, (UndetVar)qtype, to,
  15.115 +                        resultInfo, inferenceContext);
  15.116 +                }
  15.117 +            }
  15.118 +        }
  15.119 +        Assert.check(allowGraphInference || !rsInfoInfContext.free(to),
  15.120                  "legacy inference engine cannot handle constraints on both sides of a subtyping assertion");
  15.121          //we need to skip capture?
  15.122          Warner retWarn = new Warner();
  15.123 -        if (!resultInfo.checkContext.compatible(qtype1, resultInfo.checkContext.inferenceContext().asFree(to), retWarn) ||
  15.124 +        if (!resultInfo.checkContext.compatible(qtype, rsInfoInfContext.asUndetVar(to), retWarn) ||
  15.125                  //unchecked conversion is not allowed in source 7 mode
  15.126                  (!allowGraphInference && retWarn.hasLint(Lint.LintCategory.UNCHECKED))) {
  15.127              throw inferenceException
  15.128 @@ -247,30 +271,96 @@
  15.129          return from;
  15.130      }
  15.131  
  15.132 -    Type returnConstraintTarget(Type from, Type to) {
  15.133 -        if (from.hasTag(VOID)) {
  15.134 -            return syms.voidType;
  15.135 -        } else if (to.hasTag(NONE)) {
  15.136 -            return from.isPrimitive() ? from : syms.objectType;
  15.137 -        } else if (from.hasTag(UNDETVAR) && to.isPrimitive()) {
  15.138 -            if (!allowGraphInference) {
  15.139 -                //if legacy, just return boxed type
  15.140 -                return types.boxedClass(to).type;
  15.141 +    private Type generateReturnConstraintsPrimitive(JCTree tree, UndetVar from,
  15.142 +            Type to, Attr.ResultInfo resultInfo, InferenceContext inferenceContext) {
  15.143 +        if (!allowGraphInference) {
  15.144 +            //if legacy, just return boxed type
  15.145 +            return types.boxedClass(to).type;
  15.146 +        }
  15.147 +        //if graph inference we need to skip conflicting boxed bounds...
  15.148 +        for (Type t : from.getBounds(InferenceBound.EQ, InferenceBound.UPPER,
  15.149 +                InferenceBound.LOWER)) {
  15.150 +            Type boundAsPrimitive = types.unboxedType(t);
  15.151 +            if (boundAsPrimitive == null || boundAsPrimitive.hasTag(NONE)) {
  15.152 +                continue;
  15.153              }
  15.154 -            //if graph inference we need to skip conflicting boxed bounds...
  15.155 -            UndetVar uv = (UndetVar)from;
  15.156 -            for (Type t : uv.getBounds(InferenceBound.EQ, InferenceBound.LOWER)) {
  15.157 -                Type boundAsPrimitive = types.unboxedType(t);
  15.158 -                if (boundAsPrimitive == null) continue;
  15.159 -                if (types.isConvertible(boundAsPrimitive, to)) {
  15.160 -                    //effectively skip return-type constraint generation (compatibility)
  15.161 -                    return syms.objectType;
  15.162 +            return generateReferenceToTargetConstraint(tree, from, to,
  15.163 +                    resultInfo, inferenceContext);
  15.164 +        }
  15.165 +        return types.boxedClass(to).type;
  15.166 +    }
  15.167 +
  15.168 +    private Type generateReturnConstraintsUndetVarToReference(JCTree tree,
  15.169 +            UndetVar from, Type to, Attr.ResultInfo resultInfo,
  15.170 +            InferenceContext inferenceContext) {
  15.171 +        Type captureOfTo = types.capture(to);
  15.172 +        /* T is a reference type, but is not a wildcard-parameterized type, and either
  15.173 +         */
  15.174 +        if (captureOfTo == to) { //not a wildcard parameterized type
  15.175 +            /* i) B2 contains a bound of one of the forms alpha = S or S <: alpha,
  15.176 +             *      where S is a wildcard-parameterized type, or
  15.177 +             */
  15.178 +            for (Type t : from.getBounds(InferenceBound.EQ, InferenceBound.LOWER)) {
  15.179 +                Type captureOfBound = types.capture(t);
  15.180 +                if (captureOfBound != t) {
  15.181 +                    return generateReferenceToTargetConstraint(tree, from, to,
  15.182 +                            resultInfo, inferenceContext);
  15.183                  }
  15.184              }
  15.185 -            return types.boxedClass(to).type;
  15.186 -        } else {
  15.187 -            return to;
  15.188 +
  15.189 +            /* ii) B2 contains two bounds of the forms S1 <: alpha and S2 <: alpha,
  15.190 +             * where S1 and S2 have supertypes that are two different
  15.191 +             * parameterizations of the same generic class or interface.
  15.192 +             */
  15.193 +            for (Type aLowerBound : from.getBounds(InferenceBound.LOWER)) {
  15.194 +                for (Type anotherLowerBound : from.getBounds(InferenceBound.LOWER)) {
  15.195 +                    if (aLowerBound != anotherLowerBound &&
  15.196 +                        commonSuperWithDiffParameterization(aLowerBound, anotherLowerBound)) {
  15.197 +                        /* self comment check if any lower bound may be and undetVar,
  15.198 +                         * in that case the result of this call may be a false positive.
  15.199 +                         * Should this be restricted to non free types?
  15.200 +                         */
  15.201 +                        return generateReferenceToTargetConstraint(tree, from, to,
  15.202 +                            resultInfo, inferenceContext);
  15.203 +                    }
  15.204 +                }
  15.205 +            }
  15.206          }
  15.207 +
  15.208 +        /* T is a parameterization of a generic class or interface, G,
  15.209 +         * and B2 contains a bound of one of the forms alpha = S or S <: alpha,
  15.210 +         * where there exists no type of the form G<...> that is a
  15.211 +         * supertype of S, but the raw type G is a supertype of S
  15.212 +         */
  15.213 +        if (to.isParameterized()) {
  15.214 +            for (Type t : from.getBounds(InferenceBound.EQ, InferenceBound.LOWER)) {
  15.215 +                Type sup = types.asSuper(t, to.tsym);
  15.216 +                if (sup != null && sup.isRaw()) {
  15.217 +                    return generateReferenceToTargetConstraint(tree, from, to,
  15.218 +                            resultInfo, inferenceContext);
  15.219 +                }
  15.220 +            }
  15.221 +        }
  15.222 +        return to;
  15.223 +    }
  15.224 +
  15.225 +    private boolean commonSuperWithDiffParameterization(Type t, Type s) {
  15.226 +        Pair<Type, Type> supers = getParameterizedSupers(t, s);
  15.227 +        return (supers != null && !types.isSameType(supers.fst, supers.snd));
  15.228 +    }
  15.229 +
  15.230 +    private Type generateReferenceToTargetConstraint(JCTree tree, UndetVar from,
  15.231 +            Type to, Attr.ResultInfo resultInfo,
  15.232 +            InferenceContext inferenceContext) {
  15.233 +        inferenceContext.solve(List.of(from.qtype), new Warner());
  15.234 +        Type capturedType = resultInfo.checkContext.inferenceContext()
  15.235 +                .cachedCapture(tree, from.inst, false);
  15.236 +        if (types.isConvertible(capturedType,
  15.237 +                resultInfo.checkContext.inferenceContext().asUndetVar(to))) {
  15.238 +            //effectively skip additional return-type constraint generation (compatibility)
  15.239 +            return syms.objectType;
  15.240 +        }
  15.241 +        return to;
  15.242      }
  15.243  
  15.244      /**
  15.245 @@ -280,7 +370,7 @@
  15.246          ListBuffer<Type> todo = new ListBuffer<>();
  15.247          //step 1 - create fresh tvars
  15.248          for (Type t : vars) {
  15.249 -            UndetVar uv = (UndetVar)inferenceContext.asFree(t);
  15.250 +            UndetVar uv = (UndetVar)inferenceContext.asUndetVar(t);
  15.251              List<Type> upperBounds = uv.getBounds(InferenceBound.UPPER);
  15.252              if (Type.containsAny(upperBounds, vars)) {
  15.253                  TypeSymbol fresh_tvar = new TypeVariableSymbol(Flags.SYNTHETIC, uv.qtype.tsym.name, null, uv.qtype.tsym.owner);
  15.254 @@ -399,7 +489,7 @@
  15.255                  return types.createErrorType(funcInterface);
  15.256              }
  15.257              for (Type p : descParameterTypes) {
  15.258 -                if (!types.isSameType(funcInterfaceContext.asFree(p), paramTypes.head)) {
  15.259 +                if (!types.isSameType(funcInterfaceContext.asUndetVar(p), paramTypes.head)) {
  15.260                      checkContext.report(pos, diags.fragment("no.suitable.functional.intf.inst", funcInterface));
  15.261                      return types.createErrorType(funcInterface);
  15.262                  }
  15.263 @@ -515,6 +605,32 @@
  15.264          /** max number of incorporation rounds */
  15.265          static final int MAX_INCORPORATION_STEPS = 100;
  15.266  
  15.267 +    /* If for two types t and s there is a least upper bound that is a
  15.268 +     * parameterized type G, then there exists a supertype of 't' of the form
  15.269 +     * G<T1, ..., Tn> and a supertype of 's' of the form G<S1, ..., Sn>
  15.270 +     * which will be returned by this method. If no such supertypes exists then
  15.271 +     * null is returned.
  15.272 +     *
  15.273 +     * As an example for the following input:
  15.274 +     *
  15.275 +     * t = java.util.ArrayList<java.lang.String>
  15.276 +     * s = java.util.List<T>
  15.277 +     *
  15.278 +     * we get this ouput:
  15.279 +     *
  15.280 +     * Pair[java.util.List<java.lang.String>,java.util.List<T>]
  15.281 +     */
  15.282 +    private Pair<Type, Type> getParameterizedSupers(Type t, Type s) {
  15.283 +        Type lubResult = types.lub(t, s);
  15.284 +        if (lubResult == syms.errType || lubResult == syms.botType ||
  15.285 +                !lubResult.isParameterized()) {
  15.286 +            return null;
  15.287 +        }
  15.288 +        Type asSuperOfT = types.asSuper(t, lubResult.tsym);
  15.289 +        Type asSuperOfS = types.asSuper(s, lubResult.tsym);
  15.290 +        return new Pair<>(asSuperOfT, asSuperOfS);
  15.291 +    }
  15.292 +
  15.293      /**
  15.294       * This enumeration defines an entry point for doing inference variable
  15.295       * bound incorporation - it can be used to inject custom incorporation
  15.296 @@ -533,22 +649,23 @@
  15.297                  if (uv.inst != null) {
  15.298                      Type inst = uv.inst;
  15.299                      for (Type u : uv.getBounds(InferenceBound.UPPER)) {
  15.300 -                        if (!isSubtype(inst, inferenceContext.asFree(u), warn, infer)) {
  15.301 +                        if (!isSubtype(inst, inferenceContext.asUndetVar(u), warn, infer)) {
  15.302                              infer.reportBoundError(uv, BoundErrorKind.UPPER);
  15.303                          }
  15.304                      }
  15.305                      for (Type l : uv.getBounds(InferenceBound.LOWER)) {
  15.306 -                        if (!isSubtype(inferenceContext.asFree(l), inst, warn, infer)) {
  15.307 +                        if (!isSubtype(inferenceContext.asUndetVar(l), inst, warn, infer)) {
  15.308                              infer.reportBoundError(uv, BoundErrorKind.LOWER);
  15.309                          }
  15.310                      }
  15.311                      for (Type e : uv.getBounds(InferenceBound.EQ)) {
  15.312 -                        if (!isSameType(inst, inferenceContext.asFree(e), infer)) {
  15.313 +                        if (!isSameType(inst, inferenceContext.asUndetVar(e), infer)) {
  15.314                              infer.reportBoundError(uv, BoundErrorKind.EQ);
  15.315                          }
  15.316                      }
  15.317                  }
  15.318              }
  15.319 +
  15.320              @Override
  15.321              boolean accepts(UndetVar uv, InferenceContext inferenceContext) {
  15.322                  //applies to all undetvars
  15.323 @@ -594,12 +711,12 @@
  15.324                  for (Type e : uv.getBounds(InferenceBound.EQ)) {
  15.325                      if (e.containsAny(inferenceContext.inferenceVars())) continue;
  15.326                      for (Type u : uv.getBounds(InferenceBound.UPPER)) {
  15.327 -                        if (!isSubtype(e, inferenceContext.asFree(u), warn, infer)) {
  15.328 +                        if (!isSubtype(e, inferenceContext.asUndetVar(u), warn, infer)) {
  15.329                              infer.reportBoundError(uv, BoundErrorKind.BAD_EQ_UPPER);
  15.330                          }
  15.331                      }
  15.332                      for (Type l : uv.getBounds(InferenceBound.LOWER)) {
  15.333 -                        if (!isSubtype(inferenceContext.asFree(l), e, warn, infer)) {
  15.334 +                        if (!isSubtype(inferenceContext.asUndetVar(l), e, warn, infer)) {
  15.335                              infer.reportBoundError(uv, BoundErrorKind.BAD_EQ_LOWER);
  15.336                          }
  15.337                      }
  15.338 @@ -615,7 +732,7 @@
  15.339                  Infer infer = inferenceContext.infer();
  15.340                  for (Type b1 : uv.getBounds(InferenceBound.UPPER)) {
  15.341                      for (Type b2 : uv.getBounds(InferenceBound.LOWER)) {
  15.342 -                        isSubtype(inferenceContext.asFree(b2), inferenceContext.asFree(b1), warn , infer);
  15.343 +                        isSubtype(inferenceContext.asUndetVar(b2), inferenceContext.asUndetVar(b1), warn , infer);
  15.344                      }
  15.345                  }
  15.346              }
  15.347 @@ -629,7 +746,7 @@
  15.348                  Infer infer = inferenceContext.infer();
  15.349                  for (Type b1 : uv.getBounds(InferenceBound.UPPER)) {
  15.350                      for (Type b2 : uv.getBounds(InferenceBound.EQ)) {
  15.351 -                        isSubtype(inferenceContext.asFree(b2), inferenceContext.asFree(b1), warn, infer);
  15.352 +                        isSubtype(inferenceContext.asUndetVar(b2), inferenceContext.asUndetVar(b1), warn, infer);
  15.353                      }
  15.354                  }
  15.355              }
  15.356 @@ -643,12 +760,59 @@
  15.357                  Infer infer = inferenceContext.infer();
  15.358                  for (Type b1 : uv.getBounds(InferenceBound.EQ)) {
  15.359                      for (Type b2 : uv.getBounds(InferenceBound.LOWER)) {
  15.360 -                        isSubtype(inferenceContext.asFree(b2), inferenceContext.asFree(b1), warn, infer);
  15.361 +                        isSubtype(inferenceContext.asUndetVar(b2), inferenceContext.asUndetVar(b1), warn, infer);
  15.362                      }
  15.363                  }
  15.364              }
  15.365          },
  15.366          /**
  15.367 +         * Given a bound set containing {@code alpha <: P<T>} and
  15.368 +         * {@code alpha <: P<S>} where P is a parameterized type,
  15.369 +         * perform {@code T = S} (which could lead to new bounds).
  15.370 +         */
  15.371 +        CROSS_UPPER_UPPER() {
  15.372 +            @Override
  15.373 +            public void apply(UndetVar uv, InferenceContext inferenceContext, Warner warn) {
  15.374 +                Infer infer = inferenceContext.infer();
  15.375 +                List<Type> boundList = uv.getBounds(InferenceBound.UPPER);
  15.376 +                List<Type> boundListTail = boundList.tail;
  15.377 +                while (boundList.nonEmpty()) {
  15.378 +                    List<Type> tmpTail = boundListTail;
  15.379 +                    while (tmpTail.nonEmpty()) {
  15.380 +                        Type b1 = boundList.head;
  15.381 +                        Type b2 = tmpTail.head;
  15.382 +                        if (b1 != b2) {
  15.383 +                            Pair<Type, Type> commonSupers = infer.getParameterizedSupers(b1, b2);
  15.384 +                            if (commonSupers != null) {
  15.385 +                                List<Type> allParamsSuperBound1 = commonSupers.fst.allparams();
  15.386 +                                List<Type> allParamsSuperBound2 = commonSupers.snd.allparams();
  15.387 +                                while (allParamsSuperBound1.nonEmpty() && allParamsSuperBound2.nonEmpty()) {
  15.388 +                                    //traverse the list of all params comparing them
  15.389 +                                    if (!allParamsSuperBound1.head.hasTag(WILDCARD) &&
  15.390 +                                        !allParamsSuperBound2.head.hasTag(WILDCARD)) {
  15.391 +                                        isSameType(inferenceContext.asUndetVar(allParamsSuperBound1.head),
  15.392 +                                            inferenceContext.asUndetVar(allParamsSuperBound2.head), infer);
  15.393 +                                    }
  15.394 +                                    allParamsSuperBound1 = allParamsSuperBound1.tail;
  15.395 +                                    allParamsSuperBound2 = allParamsSuperBound2.tail;
  15.396 +                                }
  15.397 +                                Assert.check(allParamsSuperBound1.isEmpty() && allParamsSuperBound2.isEmpty());
  15.398 +                            }
  15.399 +                        }
  15.400 +                        tmpTail = tmpTail.tail;
  15.401 +                    }
  15.402 +                    boundList = boundList.tail;
  15.403 +                    boundListTail = boundList.tail;
  15.404 +                }
  15.405 +            }
  15.406 +
  15.407 +            @Override
  15.408 +            boolean accepts(UndetVar uv, InferenceContext inferenceContext) {
  15.409 +                return !uv.isCaptured() &&
  15.410 +                        uv.getBounds(InferenceBound.UPPER).nonEmpty();
  15.411 +            }
  15.412 +        },
  15.413 +        /**
  15.414           * Given a bound set containing {@code alpha == S} and {@code alpha == T}
  15.415           * perform {@code S == T} (which could lead to new bounds).
  15.416           */
  15.417 @@ -658,7 +822,7 @@
  15.418                  for (Type b1 : uv.getBounds(InferenceBound.EQ)) {
  15.419                      for (Type b2 : uv.getBounds(InferenceBound.EQ)) {
  15.420                          if (b1 != b2) {
  15.421 -                            isSameType(inferenceContext.asFree(b2), inferenceContext.asFree(b1), infer);
  15.422 +                            isSameType(inferenceContext.asUndetVar(b2), inferenceContext.asUndetVar(b1), infer);
  15.423                          }
  15.424                      }
  15.425                  }
  15.426 @@ -673,7 +837,7 @@
  15.427                  Infer infer = inferenceContext.infer();
  15.428                  for (Type b : uv.getBounds(InferenceBound.UPPER)) {
  15.429                      if (inferenceContext.inferenceVars().contains(b)) {
  15.430 -                        UndetVar uv2 = (UndetVar)inferenceContext.asFree(b);
  15.431 +                        UndetVar uv2 = (UndetVar)inferenceContext.asUndetVar(b);
  15.432                          if (uv2.isCaptured()) continue;
  15.433                          //alpha <: beta
  15.434                          //0. set beta :> alpha
  15.435 @@ -699,7 +863,7 @@
  15.436                  Infer infer = inferenceContext.infer();
  15.437                  for (Type b : uv.getBounds(InferenceBound.LOWER)) {
  15.438                      if (inferenceContext.inferenceVars().contains(b)) {
  15.439 -                        UndetVar uv2 = (UndetVar)inferenceContext.asFree(b);
  15.440 +                        UndetVar uv2 = (UndetVar)inferenceContext.asUndetVar(b);
  15.441                          if (uv2.isCaptured()) continue;
  15.442                          //alpha :> beta
  15.443                          //0. set beta <: alpha
  15.444 @@ -725,7 +889,7 @@
  15.445                  Infer infer = inferenceContext.infer();
  15.446                  for (Type b : uv.getBounds(InferenceBound.EQ)) {
  15.447                      if (inferenceContext.inferenceVars().contains(b)) {
  15.448 -                        UndetVar uv2 = (UndetVar)inferenceContext.asFree(b);
  15.449 +                        UndetVar uv2 = (UndetVar)inferenceContext.asUndetVar(b);
  15.450                          if (uv2.isCaptured()) continue;
  15.451                          //alpha == beta
  15.452                          //0. set beta == alpha
  15.453 @@ -1243,7 +1407,7 @@
  15.454              Type solve(UndetVar uv, InferenceContext inferenceContext) {
  15.455                  Infer infer = inferenceContext.infer();
  15.456                  List<Type> hibounds = filterBounds(uv, inferenceContext);
  15.457 -                //note: lobounds should have at least one element
  15.458 +                //note: hibounds should have at least one element
  15.459                  Type owntype = hibounds.tail.tail == null  ? hibounds.head : infer.types.glb(hibounds);
  15.460                  if (owntype.isPrimitive() || owntype.hasTag(ERROR)) {
  15.461                      throw infer.inferenceException
  15.462 @@ -1475,7 +1639,7 @@
  15.463                          StringBuilder buf = new StringBuilder();
  15.464                          String sep = "";
  15.465                          for (Type from : data) {
  15.466 -                            UndetVar uv = (UndetVar)inferenceContext.asFree(from);
  15.467 +                            UndetVar uv = (UndetVar)inferenceContext.asUndetVar(from);
  15.468                              for (Type bound : uv.getBounds(InferenceBound.values())) {
  15.469                                  if (bound.containsAny(List.from(to.data))) {
  15.470                                      buf.append(sep);
  15.471 @@ -1684,7 +1848,7 @@
  15.472                      Set<Type> optDepsByNode = stuckDeps.get(i);
  15.473                      for (Node n_j : nodes) {
  15.474                          Type j = n_j.data.first();
  15.475 -                        UndetVar uv_i = (UndetVar)inferenceContext.asFree(i);
  15.476 +                        UndetVar uv_i = (UndetVar)inferenceContext.asUndetVar(i);
  15.477                          if (Type.containsAny(uv_i.getBounds(InferenceBound.values()), List.of(j))) {
  15.478                              //update i's bound dependencies
  15.479                              n_i.addDependency(DependencyKind.BOUND, n_j);
  15.480 @@ -1833,6 +1997,8 @@
  15.481              });
  15.482          }
  15.483  
  15.484 +        /* Returns the corresponding inference variables.
  15.485 +         */
  15.486          private List<Type> filterVars(Filter<UndetVar> fu) {
  15.487              ListBuffer<Type> res = new ListBuffer<>();
  15.488              for (Type t : undetvars) {
  15.489 @@ -1890,14 +2056,14 @@
  15.490           * undet vars (used ahead of subtyping/compatibility checks to allow propagation
  15.491           * of inference constraints).
  15.492           */
  15.493 -        final Type asFree(Type t) {
  15.494 +        final Type asUndetVar(Type t) {
  15.495              return types.subst(t, inferencevars, undetvars);
  15.496          }
  15.497  
  15.498 -        final List<Type> asFree(List<Type> ts) {
  15.499 +        final List<Type> asUndetVars(List<Type> ts) {
  15.500              ListBuffer<Type> buf = new ListBuffer<>();
  15.501              for (Type t : ts) {
  15.502 -                buf.append(asFree(t));
  15.503 +                buf.append(asUndetVar(t));
  15.504              }
  15.505              return buf.toList();
  15.506          }
  15.507 @@ -2005,8 +2171,10 @@
  15.508           * Copy variable in this inference context to the given context
  15.509           */
  15.510          void dupTo(final InferenceContext that) {
  15.511 -            that.inferencevars = that.inferencevars.appendList(inferencevars);
  15.512 -            that.undetvars = that.undetvars.appendList(undetvars);
  15.513 +            that.inferencevars = that.inferencevars.appendList(
  15.514 +                    inferencevars.diff(that.inferencevars));
  15.515 +            that.undetvars = that.undetvars.appendList(
  15.516 +                    undetvars.diff(that.undetvars));
  15.517              //set up listeners to notify original inference contexts as
  15.518              //propagated vars are inferred in new context
  15.519              for (Type t : inferencevars) {
  15.520 @@ -2073,7 +2241,7 @@
  15.521          private boolean solveBasic(List<Type> varsToSolve, EnumSet<InferenceStep> steps) {
  15.522              boolean changed = false;
  15.523              for (Type t : varsToSolve.intersect(restvars())) {
  15.524 -                UndetVar uv = (UndetVar)asFree(t);
  15.525 +                UndetVar uv = (UndetVar)asUndetVar(t);
  15.526                  for (InferenceStep step : steps) {
  15.527                      if (step.accepts(uv, this)) {
  15.528                          uv.inst = step.solve(uv, this);
  15.529 @@ -2119,6 +2287,36 @@
  15.530              //back-door to infer
  15.531              return Infer.this;
  15.532          }
  15.533 +
  15.534 +        @Override
  15.535 +        public String toString() {
  15.536 +            return "Inference vars: " + inferencevars + '\n' +
  15.537 +                   "Undet vars: " + undetvars;
  15.538 +        }
  15.539 +
  15.540 +        /* Method Types.capture() generates a new type every time it's applied
  15.541 +         * to a wildcard parameterized type. This is intended functionality but
  15.542 +         * there are some cases when what you need is not to generate a new
  15.543 +         * captured type but to check that a previously generated captured type
  15.544 +         * is correct. There are cases when caching a captured type for later
  15.545 +         * reuse is sound. In general two captures from the same AST are equal.
  15.546 +         * This is why the tree is used as the key of the map below. This map
  15.547 +         * stores a Type per AST.
  15.548 +         */
  15.549 +        Map<JCTree, Type> captureTypeCache = new HashMap<>();
  15.550 +
  15.551 +        Type cachedCapture(JCTree tree, Type t, boolean readOnly) {
  15.552 +            Type captured = captureTypeCache.get(tree);
  15.553 +            if (captured != null) {
  15.554 +                return captured;
  15.555 +            }
  15.556 +
  15.557 +            Type result = types.capture(t);
  15.558 +            if (result != t && !readOnly) { // then t is a wildcard parameterized type
  15.559 +                captureTypeCache.put(tree, result);
  15.560 +            }
  15.561 +            return result;
  15.562 +        }
  15.563      }
  15.564  
  15.565      final InferenceContext emptyContext = new InferenceContext(List.<Type>nil());

    16.1 --- a/src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java	Mon May 19 22:00:11 2014 -0700
    16.2 +++ b/src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java	Thu May 29 13:46:36 2014 -0700
    16.3 @@ -1,5 +1,5 @@
    16.4  /*
    16.5 - * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    16.6 + * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
    16.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    16.8   *
    16.9   * This code is free software; you can redistribute it and/or modify it
   16.10 @@ -36,6 +36,7 @@
   16.11  import com.sun.tools.javac.code.Symbol.ClassSymbol;
   16.12  import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol;
   16.13  import com.sun.tools.javac.code.Symbol.MethodSymbol;
   16.14 +import com.sun.tools.javac.code.Symbol.TypeSymbol;
   16.15  import com.sun.tools.javac.code.Symbol.VarSymbol;
   16.16  import com.sun.tools.javac.code.Symtab;
   16.17  import com.sun.tools.javac.code.Type;
   16.18 @@ -50,8 +51,10 @@
   16.19  
   16.20  import java.util.EnumMap;
   16.21  import java.util.HashMap;
   16.22 +import java.util.HashSet;
   16.23  import java.util.LinkedHashMap;
   16.24  import java.util.Map;
   16.25 +import java.util.Set;
   16.26  
   16.27  import static com.sun.tools.javac.comp.LambdaToMethod.LambdaSymbolKind.*;
   16.28  import static com.sun.tools.javac.code.Flags.*;
   16.29 @@ -96,6 +99,9 @@
   16.30      /** dump statistics about lambda code generation */
   16.31      private boolean dumpLambdaToMethodStats;
   16.32  
   16.33 +    /** force serializable representation, for stress testing **/
   16.34 +    private final boolean forceSerializable;
   16.35 +
   16.36      /** Flag for alternate metafactories indicating the lambda object is intended to be serializable */
   16.37      public static final int FLAG_SERIALIZABLE = 1 << 0;
   16.38  
   16.39 @@ -131,6 +137,7 @@
   16.40          Options options = Options.instance(context);
   16.41          dumpLambdaToMethodStats = options.isSet("dumpLambdaToMethodStats");
   16.42          attr = Attr.instance(context);
   16.43 +        forceSerializable = options.isSet("forceSerializable");
   16.44      }
   16.45      // </editor-fold>
   16.46  
   16.47 @@ -434,13 +441,9 @@
   16.48      public void visitVarDef(JCVariableDecl tree) {
   16.49          LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context;
   16.50          if (context != null && lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {
   16.51 -            JCExpression init = translate(tree.init);
   16.52 -            int prevPos = make.pos;
   16.53 -            try {
   16.54 -                result = make.at(tree).VarDef((VarSymbol)lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym), init);
   16.55 -            } finally {
   16.56 -                make.at(prevPos);
   16.57 -            }
   16.58 +            tree.init = translate(tree.init);
   16.59 +            tree.sym = (VarSymbol) lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym);
   16.60 +            result = tree;
   16.61          } else if (context != null && lambdaContext.getSymbolMap(TYPE_VAR).containsKey(tree.sym)) {
   16.62              JCExpression init = translate(tree.init);
   16.63              VarSymbol xsym = (VarSymbol)lambdaContext.getSymbolMap(TYPE_VAR).get(tree.sym);
   16.64 @@ -1282,7 +1285,10 @@
   16.65  
   16.66          @Override
   16.67          public void visitNewClass(JCNewClass tree) {
   16.68 -            if (lambdaNewClassFilter(context(), tree)) {
   16.69 +            TypeSymbol def = tree.type.tsym;
   16.70 +            boolean inReferencedClass = currentlyInClass(def);
   16.71 +            boolean isLocal = def.isLocal();
   16.72 +            if ((inReferencedClass && isLocal || lambdaNewClassFilter(context(), tree))) {
   16.73                  TranslationContext<?> localContext = context();
   16.74                  while (localContext != null) {
   16.75                      if (localContext.tree.getTag() == LAMBDA) {
   16.76 @@ -1292,16 +1298,16 @@
   16.77                      localContext = localContext.prev;
   16.78                  }
   16.79              }
   16.80 -            if (context() != null && tree.type.tsym.owner.kind == MTH) {
   16.81 +            if (context() != null && !inReferencedClass && isLocal) {
   16.82                  LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context();
   16.83 -                captureLocalClassDefs(tree.type.tsym, lambdaContext);
   16.84 +                captureLocalClassDefs(def, lambdaContext);
   16.85              }
   16.86              super.visitNewClass(tree);
   16.87          }
   16.88          //where
   16.89              void captureLocalClassDefs(Symbol csym, final LambdaTranslationContext lambdaContext) {
   16.90                  JCClassDecl localCDef = localClassDefs.get(csym);
   16.91 -                if (localCDef != null && localCDef.pos < lambdaContext.tree.pos) {
   16.92 +                if (localCDef != null && lambdaContext.freeVarProcessedLocalClasses.add(csym)) {
   16.93                      BasicFreeVarCollector fvc = lower.new BasicFreeVarCollector() {
   16.94                          @Override
   16.95                          void addFreeVars(ClassSymbol c) {
   16.96 @@ -1327,6 +1333,18 @@
   16.97                      fvc.scan(localCDef);
   16.98                  }
   16.99          }
  16.100 +        //where
  16.101 +        boolean currentlyInClass(Symbol csym) {
  16.102 +            for (Frame frame : frameStack) {
  16.103 +                if (frame.tree.hasTag(JCTree.Tag.CLASSDEF)) {
  16.104 +                    JCClassDecl cdef = (JCClassDecl) frame.tree;
  16.105 +                    if (cdef.sym == csym) {
  16.106 +                        return true;
  16.107 +                    }
  16.108 +                }
  16.109 +            }
  16.110 +            return false;
  16.111 +        }
  16.112  
  16.113          /**
  16.114           * Method references to local class constructors, may, if the local
  16.115 @@ -1694,6 +1712,9 @@
  16.116  
  16.117              /** does this functional expression require serialization support? */
  16.118              boolean isSerializable() {
  16.119 +                if (forceSerializable) {
  16.120 +                    return true;
  16.121 +                }
  16.122                  for (Type target : tree.targets) {
  16.123                      if (types.asSuper(target, syms.serializableType.tsym) != null) {
  16.124                          return true;
  16.125 @@ -1749,6 +1770,11 @@
  16.126  
  16.127              List<JCVariableDecl> syntheticParams;
  16.128  
  16.129 +            /**
  16.130 +             * to prevent recursion, track local classes processed
  16.131 +             */
  16.132 +            final Set<Symbol> freeVarProcessedLocalClasses;
  16.133 +
  16.134              LambdaTranslationContext(JCLambda tree) {
  16.135                  super(tree);
  16.136                  Frame frame = frameStack.head;
  16.137 @@ -1778,6 +1804,8 @@
  16.138                  translatedSymbols.put(CAPTURED_VAR, new LinkedHashMap<Symbol, Symbol>());
  16.139                  translatedSymbols.put(CAPTURED_THIS, new LinkedHashMap<Symbol, Symbol>());
  16.140                  translatedSymbols.put(TYPE_VAR, new LinkedHashMap<Symbol, Symbol>());
  16.141 +
  16.142 +                freeVarProcessedLocalClasses = new HashSet<>();
  16.143              }
  16.144  
  16.145               /**
  16.146 @@ -1888,11 +1916,11 @@
  16.147                          };
  16.148                          break;
  16.149                      case LOCAL_VAR:
  16.150 -                        ret = new VarSymbol(FINAL, name, types.erasure(sym.type), translatedSym);
  16.151 +                        ret = new VarSymbol(sym.flags() & FINAL, name, sym.type, translatedSym);
  16.152                          ((VarSymbol) ret).pos = ((VarSymbol) sym).pos;
  16.153                          break;
  16.154                      case PARAM:
  16.155 -                        ret = new VarSymbol(FINAL | PARAMETER, name, types.erasure(sym.type), translatedSym);
  16.156 +                        ret = new VarSymbol((sym.flags() & FINAL) | PARAMETER, name, types.erasure(sym.type), translatedSym);
  16.157                          ((VarSymbol) ret).pos = ((VarSymbol) sym).pos;
  16.158                          break;
  16.159                      default:

    17.1 --- a/src/share/classes/com/sun/tools/javac/comp/Lower.java	Mon May 19 22:00:11 2014 -0700
    17.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java	Thu May 29 13:46:36 2014 -0700
    17.3 @@ -1,5 +1,5 @@
    17.4  /*
    17.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    17.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    17.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.8   *
    17.9   * This code is free software; you can redistribute it and/or modify it
   17.10 @@ -2360,6 +2360,7 @@
   17.11      /** Visitor method: Translate a single node.
   17.12       *  Attach the source position from the old tree to its replacement tree.
   17.13       */
   17.14 +    @Override
   17.15      public <T extends JCTree> T translate(T tree) {
   17.16          if (tree == null) {
   17.17              return null;

    18.1 --- a/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Mon May 19 22:00:11 2014 -0700
    18.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Thu May 29 13:46:36 2014 -0700
    18.3 @@ -1,5 +1,5 @@
    18.4  /*
    18.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    18.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    18.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    18.8   *
    18.9   * This code is free software; you can redistribute it and/or modify it
   18.10 @@ -92,11 +92,10 @@
   18.11      TreeInfo treeinfo;
   18.12      Types types;
   18.13      JCDiagnostic.Factory diags;
   18.14 -    public final boolean boxingEnabled; // = source.allowBoxing();
   18.15 -    public final boolean varargsEnabled; // = source.allowVarargs();
   18.16 +    public final boolean boxingEnabled;
   18.17 +    public final boolean varargsEnabled;
   18.18      public final boolean allowMethodHandles;
   18.19 -    public final boolean allowDefaultMethods;
   18.20 -    public final boolean allowStructuralMostSpecific;
   18.21 +    public final boolean allowFunctionalInterfaceMostSpecific;
   18.22      private final boolean debugResolve;
   18.23      private final boolean compactMethodDiags;
   18.24      final EnumSet<VerboseResolutionMode> verboseResolutionMode;
   18.25 @@ -137,8 +136,7 @@
   18.26          verboseResolutionMode = VerboseResolutionMode.getVerboseResolutionMode(options);
   18.27          Target target = Target.instance(context);
   18.28          allowMethodHandles = target.hasMethodHandles();
   18.29 -        allowDefaultMethods = source.allowDefaultMethods();
   18.30 -        allowStructuralMostSpecific = source.allowStructuralMostSpecific();
   18.31 +        allowFunctionalInterfaceMostSpecific = source.allowFunctionalInterfaceMostSpecific();
   18.32          polymorphicSignatureScope = new Scope(syms.noSymbol);
   18.33  
   18.34          inapplicableMethodException = new InapplicableMethodException(diags);
   18.35 @@ -567,7 +565,7 @@
   18.36                                      tvars,
   18.37                                      (MethodType)mt,
   18.38                                      resultInfo,
   18.39 -                                    m,
   18.40 +                                    (MethodSymbol)m,
   18.41                                      argtypes,
   18.42                                      allowBoxing,
   18.43                                      useVarargs,
   18.44 @@ -775,6 +773,7 @@
   18.45          public MethodCheck mostSpecificCheck(List<Type> actuals, boolean strict) {
   18.46              return nilMethodCheck;
   18.47          }
   18.48 +
   18.49      }
   18.50  
   18.51      /**
   18.52 @@ -786,6 +785,11 @@
   18.53          void checkArg(DiagnosticPosition pos, boolean varargs, Type actual, Type formal, DeferredAttrContext deferredAttrContext, Warner warn) {
   18.54              //do nothing - actual always compatible to formals
   18.55          }
   18.56 +
   18.57 +        @Override
   18.58 +        public String toString() {
   18.59 +            return "arityMethodCheck";
   18.60 +        }
   18.61      };
   18.62  
   18.63      List<Type> dummyArgs(int length) {
   18.64 @@ -871,6 +875,11 @@
   18.65          public MethodCheck mostSpecificCheck(List<Type> actuals, boolean strict) {
   18.66              return new MostSpecificCheck(strict, actuals);
   18.67          }
   18.68 +
   18.69 +        @Override
   18.70 +        public String toString() {
   18.71 +            return "resolveMethodCheck";
   18.72 +        }
   18.73      };
   18.74  
   18.75      /**
   18.76 @@ -901,8 +910,10 @@
   18.77  
   18.78                  @Override
   18.79                  public boolean compatible(Type found, Type req, Warner warn) {
   18.80 -                    found = pendingInferenceContext.asFree(found);
   18.81 -                    req = infer.returnConstraintTarget(found, req);
   18.82 +                    found = pendingInferenceContext.asUndetVar(found);
   18.83 +                    if (found.hasTag(UNDETVAR) && req.isPrimitive()) {
   18.84 +                        req = types.boxedClass(req).type;
   18.85 +                    }
   18.86                      return super.compatible(found, req, warn);
   18.87                  }
   18.88  
   18.89 @@ -938,8 +949,8 @@
   18.90  
   18.91          public boolean compatible(Type found, Type req, Warner warn) {
   18.92              return strict ?
   18.93 -                    types.isSubtypeUnchecked(found, deferredAttrContext.inferenceContext.asFree(req), warn) :
   18.94 -                    types.isConvertible(found, deferredAttrContext.inferenceContext.asFree(req), warn);
   18.95 +                    types.isSubtypeUnchecked(found, deferredAttrContext.inferenceContext.asUndetVar(req), warn) :
   18.96 +                    types.isConvertible(found, deferredAttrContext.inferenceContext.asUndetVar(req), warn);
   18.97          }
   18.98  
   18.99          public void report(DiagnosticPosition pos, JCDiagnostic details) {
  18.100 @@ -957,6 +968,12 @@
  18.101          public DeferredAttrContext deferredAttrContext() {
  18.102              return deferredAttrContext;
  18.103          }
  18.104 +
  18.105 +        @Override
  18.106 +        public String toString() {
  18.107 +            return "MethodReferenceCheck";
  18.108 +        }
  18.109 +
  18.110      }
  18.111  
  18.112      /**
  18.113 @@ -975,7 +992,12 @@
  18.114                  DeferredType dt = (DeferredType)found;
  18.115                  return dt.check(this);
  18.116              } else {
  18.117 -                return super.check(pos, chk.checkNonVoid(pos, types.capture(U(found.baseType()))));
  18.118 +                Type uResult = U(found.baseType());
  18.119 +                Type capturedType = pos == null || pos.getTree() == null ?
  18.120 +                        types.capture(uResult) :
  18.121 +                        checkContext.inferenceContext()
  18.122 +                            .cachedCapture(pos.getTree(), uResult, true);
  18.123 +                return super.check(pos, chk.checkNonVoid(pos, capturedType));
  18.124              }
  18.125          }
  18.126  
  18.127 @@ -1059,50 +1081,47 @@
  18.128              }
  18.129  
  18.130              public boolean compatible(Type found, Type req, Warner warn) {
  18.131 -                if (!allowStructuralMostSpecific || actual == null) {
  18.132 -                    return super.compatible(found, req, warn);
  18.133 -                } else {
  18.134 -                    switch (actual.getTag()) {
  18.135 -                        case DEFERRED:
  18.136 -                            DeferredType dt = (DeferredType) actual;
  18.137 -                            DeferredType.SpeculativeCache.Entry e = dt.speculativeCache.get(deferredAttrContext.msym, deferredAttrContext.phase);
  18.138 -                            return (e == null || e.speculativeTree == deferredAttr.stuckTree)
  18.139 -                                    ? super.compatible(found, req, warn) :
  18.140 -                                      mostSpecific(found, req, e.speculativeTree, warn);
  18.141 -                        default:
  18.142 -                            return standaloneMostSpecific(found, req, actual, warn);
  18.143 +                if (allowFunctionalInterfaceMostSpecific &&
  18.144 +                        unrelatedFunctionalInterfaces(found, req) &&
  18.145 +                        (actual != null && actual.getTag() == DEFERRED)) {
  18.146 +                    DeferredType dt = (DeferredType) actual;
  18.147 +                    DeferredType.SpeculativeCache.Entry e =
  18.148 +                            dt.speculativeCache.get(deferredAttrContext.msym, deferredAttrContext.phase);
  18.149 +                    if (e != null && e.speculativeTree != deferredAttr.stuckTree) {
  18.150 +                        return functionalInterfaceMostSpecific(found, req, e.speculativeTree, warn);
  18.151                      }
  18.152                  }
  18.153 +                return super.compatible(found, req, warn);
  18.154              }
  18.155  
  18.156 -            private boolean mostSpecific(Type t, Type s, JCTree tree, Warner warn) {
  18.157 -                MostSpecificChecker msc = new MostSpecificChecker(t, s, warn);
  18.158 +            /** Whether {@code t} and {@code s} are unrelated functional interface types. */
  18.159 +            private boolean unrelatedFunctionalInterfaces(Type t, Type s) {
  18.160 +                return types.isFunctionalInterface(t.tsym) &&
  18.161 +                       types.isFunctionalInterface(s.tsym) &&
  18.162 +                       types.asSuper(t, s.tsym) == null &&
  18.163 +                       types.asSuper(s, t.tsym) == null;
  18.164 +            }
  18.165 +
  18.166 +            /** Parameters {@code t} and {@code s} are unrelated functional interface types. */
  18.167 +            private boolean functionalInterfaceMostSpecific(Type t, Type s, JCTree tree, Warner warn) {
  18.168 +                FunctionalInterfaceMostSpecificChecker msc = new FunctionalInterfaceMostSpecificChecker(t, s, warn);
  18.169                  msc.scan(tree);
  18.170                  return msc.result;
  18.171              }
  18.172  
  18.173 -            boolean polyMostSpecific(Type t1, Type t2, Warner warn) {
  18.174 -                return (!t1.isPrimitive() && t2.isPrimitive())
  18.175 -                        ? true : super.compatible(t1, t2, warn);
  18.176 -            }
  18.177 -
  18.178 -            boolean standaloneMostSpecific(Type t1, Type t2, Type exprType, Warner warn) {
  18.179 -                return (exprType.isPrimitive() == t1.isPrimitive()
  18.180 -                        && exprType.isPrimitive() != t2.isPrimitive())
  18.181 -                        ? true : super.compatible(t1, t2, warn);
  18.182 -            }
  18.183 -
  18.184              /**
  18.185 -             * Structural checker for most specific.
  18.186 +             * Tests whether one functional interface type can be considered more specific
  18.187 +             * than another unrelated functional interface type for the scanned expression.
  18.188               */
  18.189 -            class MostSpecificChecker extends DeferredAttr.PolyScanner {
  18.190 +            class FunctionalInterfaceMostSpecificChecker extends DeferredAttr.PolyScanner {
  18.191  
  18.192                  final Type t;
  18.193                  final Type s;
  18.194                  final Warner warn;
  18.195                  boolean result;
  18.196  
  18.197 -                MostSpecificChecker(Type t, Type s, Warner warn) {
  18.198 +                /** Parameters {@code t} and {@code s} are unrelated functional interface types. */
  18.199 +                FunctionalInterfaceMostSpecificChecker(Type t, Type s, Warner warn) {
  18.200                      this.t = t;
  18.201                      this.s = s;
  18.202                      this.warn = warn;
  18.203 @@ -1111,102 +1130,96 @@
  18.204  
  18.205                  @Override
  18.206                  void skip(JCTree tree) {
  18.207 -                    result &= standaloneMostSpecific(t, s, tree.type, warn);
  18.208 +                    result &= false;
  18.209                  }
  18.210  
  18.211                  @Override
  18.212                  public void visitConditional(JCConditional tree) {
  18.213 -                    if (tree.polyKind == PolyKind.STANDALONE) {
  18.214 -                        result &= standaloneMostSpecific(t, s, tree.type, warn);
  18.215 +                    scan(tree.truepart);
  18.216 +                    scan(tree.falsepart);
  18.217 +                }
  18.218 +
  18.219 +                @Override
  18.220 +                public void visitReference(JCMemberReference tree) {
  18.221 +                    Type desc_t = types.findDescriptorType(t);
  18.222 +                    Type desc_s = types.findDescriptorType(s);
  18.223 +                    // use inference variables here for more-specific inference (18.5.4)
  18.224 +                    if (!types.isSameTypes(desc_t.getParameterTypes(),
  18.225 +                            inferenceContext().asUndetVars(desc_s.getParameterTypes()))) {
  18.226 +                        result &= false;
  18.227                      } else {
  18.228 -                        super.visitConditional(tree);
  18.229 +                        // compare return types
  18.230 +                        Type ret_t = desc_t.getReturnType();
  18.231 +                        Type ret_s = desc_s.getReturnType();
  18.232 +                        if (ret_s.hasTag(VOID)) {
  18.233 +                            result &= true;
  18.234 +                        } else if (ret_t.hasTag(VOID)) {
  18.235 +                            result &= false;
  18.236 +                        } else if (ret_t.isPrimitive() != ret_s.isPrimitive()) {
  18.237 +                            boolean retValIsPrimitive =
  18.238 +                                    tree.refPolyKind == PolyKind.STANDALONE &&
  18.239 +                                    tree.sym.type.getReturnType().isPrimitive();
  18.240 +                            result &= (retValIsPrimitive == ret_t.isPrimitive()) &&
  18.241 +                                      (retValIsPrimitive != ret_s.isPrimitive());
  18.242 +                        } else {
  18.243 +                            result &= MostSpecificCheckContext.super.compatible(ret_t, ret_s, warn);
  18.244 +                        }
  18.245                      }
  18.246                  }
  18.247  
  18.248                  @Override
  18.249 -                public void visitApply(JCMethodInvocation tree) {
  18.250 -                    result &= (tree.polyKind == PolyKind.STANDALONE)
  18.251 -                            ? standaloneMostSpecific(t, s, tree.type, warn)
  18.252 -                            : polyMostSpecific(t, s, warn);
  18.253 -                }
  18.254 -
  18.255 -                @Override
  18.256 -                public void visitNewClass(JCNewClass tree) {
  18.257 -                    result &= (tree.polyKind == PolyKind.STANDALONE)
  18.258 -                            ? standaloneMostSpecific(t, s, tree.type, warn)
  18.259 -                            : polyMostSpecific(t, s, warn);
  18.260 -                }
  18.261 -
  18.262 -                @Override
  18.263 -                public void visitReference(JCMemberReference tree) {
  18.264 -                    if (types.isFunctionalInterface(t.tsym) &&
  18.265 -                            types.isFunctionalInterface(s.tsym)) {
  18.266 -                        Type desc_t = types.findDescriptorType(t);
  18.267 -                        Type desc_s = types.findDescriptorType(s);
  18.268 -                        if (types.isSameTypes(desc_t.getParameterTypes(),
  18.269 -                                inferenceContext().asFree(desc_s.getParameterTypes()))) {
  18.270 -                            if (types.asSuper(t, s.tsym) != null ||
  18.271 -                                types.asSuper(s, t.tsym) != null) {
  18.272 -                                result &= MostSpecificCheckContext.super.compatible(t, s, warn);
  18.273 -                            } else if (!desc_s.getReturnType().hasTag(VOID)) {
  18.274 -                                //perform structural comparison
  18.275 -                                Type ret_t = desc_t.getReturnType();
  18.276 -                                Type ret_s = desc_s.getReturnType();
  18.277 -                                result &= ((tree.refPolyKind == PolyKind.STANDALONE)
  18.278 -                                        ? standaloneMostSpecific(ret_t, ret_s, tree.sym.type.getReturnType(), warn)
  18.279 -                                        : polyMostSpecific(ret_t, ret_s, warn));
  18.280 -                            } else {
  18.281 -                                return;
  18.282 +                public void visitLambda(JCLambda tree) {
  18.283 +                    Type desc_t = types.findDescriptorType(t);
  18.284 +                    Type desc_s = types.findDescriptorType(s);
  18.285 +                    // use inference variables here for more-specific inference (18.5.4)
  18.286 +                    if (!types.isSameTypes(desc_t.getParameterTypes(),
  18.287 +                            inferenceContext().asUndetVars(desc_s.getParameterTypes()))) {
  18.288 +                        result &= false;
  18.289 +                    } else {
  18.290 +                        // compare return types
  18.291 +                        Type ret_t = desc_t.getReturnType();
  18.292 +                        Type ret_s = desc_s.getReturnType();
  18.293 +                        if (ret_s.hasTag(VOID)) {
  18.294 +                            result &= true;
  18.295 +                        } else if (ret_t.hasTag(VOID)) {
  18.296 +                            result &= false;
  18.297 +                        } else if (unrelatedFunctionalInterfaces(ret_t, ret_s)) {
  18.298 +                            for (JCExpression expr : lambdaResults(tree)) {
  18.299 +                                result &= functionalInterfaceMostSpecific(ret_t, ret_s, expr, warn);
  18.300                              }
  18.301 +                        } else if (ret_t.isPrimitive() != ret_s.isPrimitive()) {
  18.302 +                            for (JCExpression expr : lambdaResults(tree)) {
  18.303 +                                boolean retValIsPrimitive = expr.isStandalone() && expr.type.isPrimitive();
  18.304 +                                result &= (retValIsPrimitive == ret_t.isPrimitive()) &&
  18.305 +                                          (retValIsPrimitive != ret_s.isPrimitive());
  18.306 +                            }
  18.307 +                        } else {
  18.308 +                            result &= MostSpecificCheckContext.super.compatible(ret_t, ret_s, warn);
  18.309                          }
  18.310 -                    } else {
  18.311 -                        result &= false;
  18.312 -                    }
  18.313 -                }
  18.314 -
  18.315 -                @Override
  18.316 -                public void visitLambda(JCLambda tree) {
  18.317 -                    if (types.isFunctionalInterface(t.tsym) &&
  18.318 -                            types.isFunctionalInterface(s.tsym)) {
  18.319 -                        Type desc_t = types.findDescriptorType(t);
  18.320 -                        Type desc_s = types.findDescriptorType(s);
  18.321 -                        if (types.isSameTypes(desc_t.getParameterTypes(),
  18.322 -                                inferenceContext().asFree(desc_s.getParameterTypes()))) {
  18.323 -                            if (types.asSuper(t, s.tsym) != null ||
  18.324 -                                types.asSuper(s, t.tsym) != null) {
  18.325 -                                result &= MostSpecificCheckContext.super.compatible(t, s, warn);
  18.326 -                            } else if (!desc_s.getReturnType().hasTag(VOID)) {
  18.327 -                                //perform structural comparison
  18.328 -                                Type ret_t = desc_t.getReturnType();
  18.329 -                                Type ret_s = desc_s.getReturnType();
  18.330 -                                scanLambdaBody(tree, ret_t, ret_s);
  18.331 -                            } else {
  18.332 -                                return;
  18.333 -                            }
  18.334 -                        }
  18.335 -                    } else {
  18.336 -                        result &= false;
  18.337                      }
  18.338                  }
  18.339                  //where
  18.340  
  18.341 -                void scanLambdaBody(JCLambda lambda, final Type t, final Type s) {
  18.342 +                private List<JCExpression> lambdaResults(JCLambda lambda) {
  18.343                      if (lambda.getBodyKind() == JCTree.JCLambda.BodyKind.EXPRESSION) {
  18.344 -                        result &= MostSpecificCheckContext.this.mostSpecific(t, s, lambda.body, warn);
  18.345 +                        return List.of((JCExpression) lambda.body);
  18.346                      } else {
  18.347 +                        final ListBuffer<JCExpression> buffer = new ListBuffer<>();
  18.348                          DeferredAttr.LambdaReturnScanner lambdaScanner =
  18.349                                  new DeferredAttr.LambdaReturnScanner() {
  18.350                                      @Override
  18.351                                      public void visitReturn(JCReturn tree) {
  18.352                                          if (tree.expr != null) {
  18.353 -                                            result &= MostSpecificCheckContext.this.mostSpecific(t, s, tree.expr, warn);
  18.354 +                                            buffer.append(tree.expr);
  18.355                                          }
  18.356                                      }
  18.357                                  };
  18.358                          lambdaScanner.scan(lambda.body);
  18.359 +                        return buffer.toList();
  18.360                      }
  18.361                  }
  18.362              }
  18.363 +
  18.364          }
  18.365  
  18.366          public MethodCheck mostSpecificCheck(List<Type> actuals, boolean strict) {
  18.367 @@ -1410,7 +1423,7 @@
  18.368              return bestSoFar;
  18.369          } else if (useVarargs && (sym.flags() & VARARGS) == 0) {
  18.370              return bestSoFar.kind >= ERRONEOUS ?
  18.371 -                    new BadVarargsMethod((ResolveError)bestSoFar) :
  18.372 +                    new BadVarargsMethod((ResolveError)bestSoFar.baseSymbol()) :
  18.373                      bestSoFar;
  18.374          }
  18.375          Assert.check(sym.kind < AMBIGUOUS);
  18.376 @@ -1502,14 +1515,22 @@
  18.377              if (m2SignatureMoreSpecific) return m2;
  18.378              return ambiguityError(m1, m2);
  18.379          case AMBIGUOUS:
  18.380 -            //check if m1 is more specific than all ambiguous methods in m2
  18.381 +            //compare m1 to ambiguous methods in m2
  18.382              AmbiguityError e = (AmbiguityError)m2.baseSymbol();
  18.383 +            boolean m1MoreSpecificThanAnyAmbiguous = true;
  18.384 +            boolean allAmbiguousMoreSpecificThanM1 = true;
  18.385              for (Symbol s : e.ambiguousSyms) {
  18.386 -                if (mostSpecific(argtypes, m1, s, env, site, allowBoxing, useVarargs) != m1) {
  18.387 -                    return e.addAmbiguousSymbol(m1);
  18.388 -                }
  18.389 +                Symbol moreSpecific = mostSpecific(argtypes, m1, s, env, site, allowBoxing, useVarargs);
  18.390 +                m1MoreSpecificThanAnyAmbiguous &= moreSpecific == m1;
  18.391 +                allAmbiguousMoreSpecificThanM1 &= moreSpecific == s;
  18.392              }
  18.393 -            return m1;
  18.394 +            if (m1MoreSpecificThanAnyAmbiguous)
  18.395 +                return m1;
  18.396 +            //if m1 is more specific than some ambiguous methods, but other ambiguous methods are
  18.397 +            //more specific than m1, add it as a new ambiguous method:
  18.398 +            if (!allAmbiguousMoreSpecificThanM1)
  18.399 +                e.addAmbiguousSymbol(m1);
  18.400 +            return e;
  18.401          default:
  18.402              throw new AssertionError();
  18.403          }
  18.404 @@ -1527,7 +1548,7 @@
  18.405              currentResolutionContext.methodCheck =
  18.406                      prevResolutionContext.methodCheck.mostSpecificCheck(actuals, !allowBoxing);
  18.407              Type mst = instantiate(env, site, m2, null,
  18.408 -                    adjustArgs(types.lowerBounds(types.memberType(site, m1).getParameterTypes()), m1, maxLength, useVarargs), null,
  18.409 +                    adjustArgs(types.cvarLowerBounds(types.memberType(site, m1).getParameterTypes()), m1, maxLength, useVarargs), null,
  18.410                      allowBoxing, useVarargs, noteWarner);
  18.411              return mst != null &&
  18.412                      !noteWarner.hasLint(Lint.LintCategory.UNCHECKED);
  18.413 @@ -1681,7 +1702,6 @@
  18.414                  bestSoFar : methodNotFound;
  18.415  
  18.416          for (InterfaceLookupPhase iphase2 : InterfaceLookupPhase.values()) {
  18.417 -            if (iphase2 == InterfaceLookupPhase.DEFAULT_OK && !allowDefaultMethods) break;
  18.418              //keep searching for abstract methods
  18.419              for (Type itype : itypes[iphase2.ordinal()]) {
  18.420                  if (!itype.isInterface()) continue; //skip j.l.Object (included by Types.closure())
  18.421 @@ -1714,10 +1734,8 @@
  18.422                  //from superinterfaces)
  18.423                  if ((s.flags() & (ABSTRACT | INTERFACE | ENUM)) != 0) {
  18.424                      return this;
  18.425 -                } else if (rs.allowDefaultMethods) {
  18.426 +                } else {
  18.427                      return DEFAULT_OK;
  18.428 -                } else {
  18.429 -                    return null;
  18.430                  }
  18.431              }
  18.432          },
  18.433 @@ -2173,7 +2191,7 @@
  18.434                    List<Type> typeargtypes,
  18.435                    LogResolveHelper logResolveHelper) {
  18.436          if (sym.kind >= AMBIGUOUS) {
  18.437 -            ResolveError errSym = (ResolveError)sym;
  18.438 +            ResolveError errSym = (ResolveError)sym.baseSymbol();
  18.439              sym = errSym.access(name, qualified ? site.tsym : syms.noSymbol);
  18.440              argtypes = logResolveHelper.getArgumentTypes(errSym, sym, name, argtypes);
  18.441              if (logResolveHelper.resolveDiagnosticNeeded(site, argtypes, typeargtypes)) {
  18.442 @@ -2562,7 +2580,7 @@
  18.443                                  sym = super.access(env, pos, location, sym);
  18.444                              } else {
  18.445                                  final JCDiagnostic details = sym.kind == WRONG_MTH ?
  18.446 -                                                ((InapplicableSymbolError)sym).errCandidate().snd :
  18.447 +                                                ((InapplicableSymbolError)sym.baseSymbol()).errCandidate().snd :
  18.448                                                  null;
  18.449                                  sym = new InapplicableSymbolError(sym.kind, "diamondError", currentResolutionContext) {
  18.450                                      @Override
  18.451 @@ -2970,12 +2988,12 @@
  18.452                      return true;
  18.453                  case WRONG_MTH:
  18.454                      InapplicableSymbolError errSym =
  18.455 -                            (InapplicableSymbolError)s;
  18.456 +                            (InapplicableSymbolError)s.baseSymbol();
  18.457                      return new Template(MethodCheckDiag.ARITY_MISMATCH.regex())
  18.458                              .matches(errSym.errCandidate().snd);
  18.459                  case WRONG_MTHS:
  18.460                      InapplicableSymbolsError errSyms =
  18.461 -                            (InapplicableSymbolsError)s;
  18.462 +                            (InapplicableSymbolsError)s.baseSymbol();
  18.463                      return errSyms.filterCandidates(errSyms.mapCandidates()).isEmpty();
  18.464                  case WRONG_STATICNESS:
  18.465                      return false;
  18.466 @@ -3157,7 +3175,7 @@
  18.467              if (TreeInfo.isStaticSelector(referenceTree.expr, names) &&
  18.468                      argtypes.nonEmpty() &&
  18.469                      (argtypes.head.hasTag(NONE) ||
  18.470 -                    types.isSubtypeUnchecked(inferenceContext.asFree(argtypes.head), site))) {
  18.471 +                    types.isSubtypeUnchecked(inferenceContext.asUndetVar(argtypes.head), site))) {
  18.472                  return new UnboundMethodReferenceLookupHelper(referenceTree, name,
  18.473                          site, argtypes, typeargtypes, maxPhase);
  18.474              } else {
  18.475 @@ -3341,9 +3359,9 @@
  18.476              if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;
  18.477              env1 = env1.outer;
  18.478          }
  18.479 -        if (allowDefaultMethods && c.isInterface() &&
  18.480 -                name == names._super && !isStatic(env) &&
  18.481 -                types.isDirectSuperInterface(c, env.enclClass.sym)) {
  18.482 +        if (c.isInterface() &&
  18.483 +            name == names._super && !isStatic(env) &&
  18.484 +            types.isDirectSuperInterface(c, env.enclClass.sym)) {
  18.485              //this might be a default super call if one of the superinterfaces is 'c'
  18.486              for (Type t : pruneInterfaces(env.enclClass.type)) {
  18.487                  if (t.tsym == c) {
  18.488 @@ -4270,7 +4288,11 @@
  18.489          }
  18.490  
  18.491          DeferredAttrContext deferredAttrContext(Symbol sym, InferenceContext inferenceContext, ResultInfo pendingResult, Warner warn) {
  18.492 -            return deferredAttr.new DeferredAttrContext(attrMode, sym, step, inferenceContext, pendingResult != null ? pendingResult.checkContext.deferredAttrContext() : deferredAttr.emptyDeferredAttrContext, warn);
  18.493 +            DeferredAttrContext parent = (pendingResult == null)
  18.494 +                ? deferredAttr.emptyDeferredAttrContext
  18.495 +                : pendingResult.checkContext.deferredAttrContext();
  18.496 +            return deferredAttr.new DeferredAttrContext(attrMode, sym, step,
  18.497 +                    inferenceContext, parent, warn);
  18.498          }
  18.499  
  18.500          /**

    19.1 --- a/src/share/classes/com/sun/tools/javac/comp/TransTypes.java	Mon May 19 22:00:11 2014 -0700
    19.2 +++ b/src/share/classes/com/sun/tools/javac/comp/TransTypes.java	Thu May 29 13:46:36 2014 -0700
    19.3 @@ -1,5 +1,5 @@
    19.4  /*
    19.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    19.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    19.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    19.8   *
    19.9   * This code is free software; you can redistribute it and/or modify it
   19.10 @@ -835,6 +835,8 @@
   19.11      public void visitReference(JCMemberReference tree) {
   19.12          tree.expr = translate(tree.expr, erasure(tree.expr.type));
   19.13          tree.type = erasure(tree.type);
   19.14 +        if (tree.varargsElement != null)
   19.15 +            tree.varargsElement = erasure(tree.varargsElement);
   19.16          result = tree;
   19.17      }
   19.18  

    20.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Mon May 19 22:00:11 2014 -0700
    20.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Thu May 29 13:46:36 2014 -0700
    20.3 @@ -1,5 +1,5 @@
    20.4  /*
    20.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    20.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    20.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    20.8   *
    20.9   * This code is free software; you can redistribute it and/or modify it
   20.10 @@ -116,10 +116,6 @@
   20.11       */
   20.12      boolean lintClassfile;
   20.13  
   20.14 -    /** Switch: allow default methods
   20.15 -     */
   20.16 -    boolean allowDefaultMethods;
   20.17 -
   20.18      /** Switch: preserve parameter names from the variable table.
   20.19       */
   20.20      public boolean saveParameterNames;
   20.21 @@ -307,7 +303,6 @@
   20.22          allowVarargs     = source.allowVarargs();
   20.23          allowAnnotations = source.allowAnnotations();
   20.24          allowSimplifiedVarargs = source.allowSimplifiedVarargs();
   20.25 -        allowDefaultMethods = source.allowDefaultMethods();
   20.26  
   20.27          saveParameterNames = options.isSet("save-parameter-names");
   20.28          cacheCompletionFailure = options.isUnset("dev");
   20.29 @@ -517,14 +512,14 @@
   20.30              break;
   20.31          case CONSTANT_Fieldref: {
   20.32              ClassSymbol owner = readClassSymbol(getChar(index + 1));
   20.33 -            NameAndType nt = (NameAndType)readPool(getChar(index + 3));
   20.34 +            NameAndType nt = readNameAndType(getChar(index + 3));
   20.35              poolObj[i] = new VarSymbol(0, nt.name, nt.uniqueType.type, owner);
   20.36              break;
   20.37          }
   20.38          case CONSTANT_Methodref:
   20.39          case CONSTANT_InterfaceMethodref: {
   20.40              ClassSymbol owner = readClassSymbol(getChar(index + 1));
   20.41 -            NameAndType nt = (NameAndType)readPool(getChar(index + 3));
   20.42 +            NameAndType nt = readNameAndType(getChar(index + 3));
   20.43              poolObj[i] = new MethodSymbol(0, nt.name, nt.uniqueType.type, owner);
   20.44              break;
   20.45          }
   20.46 @@ -593,13 +588,34 @@
   20.47      /** Read class entry.
   20.48       */
   20.49      ClassSymbol readClassSymbol(int i) {
   20.50 -        return (ClassSymbol) (readPool(i));
   20.51 +        Object obj = readPool(i);
   20.52 +        if (obj != null && !(obj instanceof ClassSymbol))
   20.53 +            throw badClassFile("bad.const.pool.entry",
   20.54 +                               currentClassFile.toString(),
   20.55 +                               "CONSTANT_Class_info", i);
   20.56 +        return (ClassSymbol)obj;
   20.57      }
   20.58  
   20.59      /** Read name.
   20.60       */
   20.61      Name readName(int i) {
   20.62 -        return (Name) (readPool(i));
   20.63 +        Object obj = readPool(i);
   20.64 +        if (obj != null && !(obj instanceof Name))
   20.65 +            throw badClassFile("bad.const.pool.entry",
   20.66 +                               currentClassFile.toString(),
   20.67 +                               "CONSTANT_Utf8_info or CONSTANT_String_info", i);
   20.68 +        return (Name)obj;
   20.69 +    }
   20.70 +
   20.71 +    /** Read name and type.
   20.72 +     */
   20.73 +    NameAndType readNameAndType(int i) {
   20.74 +        Object obj = readPool(i);
   20.75 +        if (obj != null && !(obj instanceof NameAndType))
   20.76 +            throw badClassFile("bad.const.pool.entry",
   20.77 +                               currentClassFile.toString(),
   20.78 +                               "CONSTANT_NameAndType_info", i);
   20.79 +        return (NameAndType)obj;
   20.80      }
   20.81  
   20.82  /************************************************************************
   20.83 @@ -1250,7 +1266,7 @@
   20.84          sym.owner.members().remove(sym);
   20.85          ClassSymbol self = (ClassSymbol)sym;
   20.86          ClassSymbol c = readClassSymbol(nextChar());
   20.87 -        NameAndType nt = (NameAndType)readPool(nextChar());
   20.88 +        NameAndType nt = readNameAndType(nextChar());
   20.89  
   20.90          if (c.members_field == null)
   20.91              throw badClassFile("bad.enclosing.class", self, c);

    21.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Mon May 19 22:00:11 2014 -0700
    21.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Thu May 29 13:46:36 2014 -0700
    21.3 @@ -1038,7 +1038,7 @@
    21.4              }
    21.5              databuf.appendChar(pool.get(inner));
    21.6              databuf.appendChar(
    21.7 -                inner.owner.kind == TYP ? pool.get(inner.owner) : 0);
    21.8 +                inner.owner.kind == TYP && !inner.name.isEmpty() ? pool.get(inner.owner) : 0);
    21.9              databuf.appendChar(
   21.10                  !inner.name.isEmpty() ? pool.get(inner.name) : 0);
   21.11              databuf.appendChar(flags);

    22.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Code.java	Mon May 19 22:00:11 2014 -0700
    22.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Code.java	Thu May 29 13:46:36 2014 -0700
    22.3 @@ -1,5 +1,5 @@
    22.4  /*
    22.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    22.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    22.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    22.8   *
    22.9   * This code is free software; you can redistribute it and/or modify it
   22.10 @@ -2189,9 +2189,9 @@
   22.11          // Keep local variables if
   22.12          // 1) we need them for debug information
   22.13          // 2) it is an exception type and it contains type annotations
   22.14 -        if (!varDebugInfo &&
   22.15 -                (!var.sym.isExceptionParameter() ||
   22.16 -                var.sym.hasTypeAnnotations())) return;
   22.17 +        boolean keepLocalVariables = varDebugInfo ||
   22.18 +            (var.sym.isExceptionParameter() && var.sym.hasTypeAnnotations());
   22.19 +        if (!keepLocalVariables) return;
   22.20          if ((var.sym.flags() & Flags.SYNTHETIC) != 0) return;
   22.21          if (varBuffer == null)
   22.22              varBuffer = new LocalVar[20];

    23.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Mon May 19 22:00:11 2014 -0700
    23.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Thu May 29 13:46:36 2014 -0700
    23.3 @@ -1,5 +1,5 @@
    23.4  /*
    23.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    23.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    23.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    23.8   *
    23.9   * This code is free software; you can redistribute it and/or modify it
   23.10 @@ -2818,7 +2818,7 @@
   23.11          }
   23.12  
   23.13          private LVTAssignAnalyzer(LVTRanges lvtRanges, Symtab syms, Names names) {
   23.14 -            super(new LVTBits(), syms, names);
   23.15 +            super(new LVTBits(), syms, names, false);
   23.16              lvtInits = (LVTBits)inits;
   23.17              this.lvtRanges = lvtRanges;
   23.18          }

    24.1 --- a/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Mon May 19 22:00:11 2014 -0700
    24.2 +++ b/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Thu May 29 13:46:36 2014 -0700
    24.3 @@ -35,9 +35,6 @@
    24.4  import java.util.Queue;
    24.5  import java.util.ResourceBundle;
    24.6  import java.util.Set;
    24.7 -import java.util.logging.Handler;
    24.8 -import java.util.logging.Level;
    24.9 -import java.util.logging.Logger;
   24.10  
   24.11  import javax.annotation.processing.Processor;
   24.12  import javax.lang.model.SourceVersion;
   24.13 @@ -1304,11 +1301,16 @@
   24.14       * Perform dataflow checks on an attributed parse tree.
   24.15       */
   24.16      protected void flow(Env<AttrContext> env, Queue<Env<AttrContext>> results) {
   24.17 +        if (compileStates.isDone(env, CompileState.FLOW)) {
   24.18 +            results.add(env);
   24.19 +            return;
   24.20 +        }
   24.21 +
   24.22          try {
   24.23              if (shouldStop(CompileState.FLOW))
   24.24                  return;
   24.25  
   24.26 -            if (relax || compileStates.isDone(env, CompileState.FLOW)) {
   24.27 +            if (relax) {
   24.28                  results.add(env);
   24.29                  return;
   24.30              }

    25.1 --- a/src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java	Mon May 19 22:00:11 2014 -0700
    25.2 +++ b/src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java	Thu May 29 13:46:36 2014 -0700
    25.3 @@ -1,5 +1,5 @@
    25.4  /*
    25.5 - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
    25.6 + * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
    25.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    25.8   *
    25.9   * This code is free software; you can redistribute it and/or modify it
   25.10 @@ -1172,8 +1172,10 @@
   25.11                              DCText string = quotedString();
   25.12                              if (string != null) {
   25.13                                  skipWhitespace();
   25.14 -                                if (ch == '@')
   25.15 +                                if (ch == '@'
   25.16 +                                        || ch == EOI && bp == buf.length - 1) {
   25.17                                      return m.at(pos).See(List.<DCTree>of(string));
   25.18 +                                }
   25.19                              }
   25.20                              break;
   25.21  

    26.1 --- a/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Mon May 19 22:00:11 2014 -0700
    26.2 +++ b/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Thu May 29 13:46:36 2014 -0700
    26.3 @@ -161,6 +161,7 @@
    26.4          this.allowStaticInterfaceMethods = source.allowStaticInterfaceMethods();
    26.5          this.allowIntersectionTypesInCast = source.allowIntersectionTypesInCast();
    26.6          this.allowTypeAnnotations = source.allowTypeAnnotations();
    26.7 +        this.allowAnnotationsAfterTypeParams = source.allowAnnotationsAfterTypeParams();
    26.8          this.keepDocComments = keepDocComments;
    26.9          docComments = newDocCommentTable(keepDocComments, fac);
   26.10          this.keepLineMap = keepLineMap;
   26.11 @@ -254,6 +255,10 @@
   26.12       */
   26.13      boolean allowTypeAnnotations;
   26.14  
   26.15 +    /** Switch: should we allow annotations after the method type parameters?
   26.16 +     */
   26.17 +    boolean allowAnnotationsAfterTypeParams;
   26.18 +
   26.19      /** Switch: is "this" allowed as an identifier?
   26.20       * This is needed to parse receiver types.
   26.21       */
   26.22 @@ -2020,7 +2025,7 @@
   26.23      /** Creator = [Annotations] Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
   26.24       */
   26.25      JCExpression creator(int newpos, List<JCExpression> typeArgs) {
   26.26 -        List<JCAnnotation> newAnnotations = annotationsOpt(Tag.ANNOTATION);
   26.27 +        List<JCAnnotation> newAnnotations = typeAnnotationsOpt();
   26.28  
   26.29          switch (token.kind) {
   26.30          case BYTE: case SHORT: case CHAR: case INT: case LONG: case FLOAT:
   26.31 @@ -3401,16 +3406,28 @@
   26.32       *    | ModifiersOpt
   26.33       *      ( Type Ident
   26.34       *        ( VariableDeclaratorsRest ";" | MethodDeclaratorRest )
   26.35 -     *      | VOID Ident MethodDeclaratorRest
   26.36 -     *      | TypeParameters (Type | VOID) Ident MethodDeclaratorRest
   26.37 +     *      | VOID Ident VoidMethodDeclaratorRest
   26.38 +     *      | TypeParameters [Annotations]
   26.39 +     *        ( Type Ident MethodDeclaratorRest
   26.40 +     *        | VOID Ident VoidMethodDeclaratorRest
   26.41 +     *        )
   26.42       *      | Ident ConstructorDeclaratorRest
   26.43       *      | TypeParameters Ident ConstructorDeclaratorRest
   26.44       *      | ClassOrInterfaceOrEnumDeclaration
   26.45       *      )
   26.46       *  InterfaceBodyDeclaration =
   26.47       *      ";"
   26.48 -     *    | ModifiersOpt Type Ident
   26.49 -     *      ( ConstantDeclaratorsRest | InterfaceMethodDeclaratorRest ";" )
   26.50 +     *    | ModifiersOpt
   26.51 +     *      ( Type Ident
   26.52 +     *        ( ConstantDeclaratorsRest ";" | MethodDeclaratorRest )
   26.53 +     *      | VOID Ident MethodDeclaratorRest
   26.54 +     *      | TypeParameters [Annotations]
   26.55 +     *        ( Type Ident MethodDeclaratorRest
   26.56 +     *        | VOID Ident VoidMethodDeclaratorRest
   26.57 +     *        )
   26.58 +     *      | ClassOrInterfaceOrEnumDeclaration
   26.59 +     *      )
   26.60 +     *
   26.61       */
   26.62      protected List<JCTree> classOrInterfaceBodyDeclaration(Name className, boolean isInterface) {
   26.63          if (token.kind == SEMI) {
   26.64 @@ -3439,27 +3456,29 @@
   26.65                  }
   26.66                  List<JCAnnotation> annosAfterParams = annotationsOpt(Tag.ANNOTATION);
   26.67  
   26.68 +                if (annosAfterParams.nonEmpty()) {
   26.69 +                    checkAnnotationsAfterTypeParams(annosAfterParams.head.pos);
   26.70 +                    mods.annotations = mods.annotations.appendList(annosAfterParams);
   26.71 +                    if (mods.pos == Position.NOPOS)
   26.72 +                        mods.pos = mods.annotations.head.pos;
   26.73 +                }
   26.74 +
   26.75                  Token tk = token;
   26.76                  pos = token.pos;
   26.77                  JCExpression type;
   26.78                  boolean isVoid = token.kind == VOID;
   26.79                  if (isVoid) {
   26.80 -                    if (annosAfterParams.nonEmpty())
   26.81 -                        illegal(annosAfterParams.head.pos);
   26.82                      type = to(F.at(pos).TypeIdent(TypeTag.VOID));
   26.83                      nextToken();
   26.84                  } else {
   26.85 -                    if (annosAfterParams.nonEmpty()) {
   26.86 -                        mods.annotations = mods.annotations.appendList(annosAfterParams);
   26.87 -                        if (mods.pos == Position.NOPOS)
   26.88 -                            mods.pos = mods.annotations.head.pos;
   26.89 -                    }
   26.90                      // method returns types are un-annotated types
   26.91                      type = unannotatedType();
   26.92                  }
   26.93                  if (token.kind == LPAREN && !isInterface && type.hasTag(IDENT)) {
   26.94                      if (isInterface || tk.name() != className)
   26.95                          error(pos, "invalid.meth.decl.ret.type.req");
   26.96 +                    else if (annosAfterParams.nonEmpty())
   26.97 +                        illegal(annosAfterParams.head.pos);
   26.98                      return List.of(methodDeclaratorRest(
   26.99                          pos, mods, null, names.init, typarams,
  26.100                          isInterface, true, dc));
  26.101 @@ -3491,13 +3510,9 @@
  26.102      }
  26.103  
  26.104      /** MethodDeclaratorRest =
  26.105 -     *      FormalParameters BracketsOpt [Throws TypeList] ( MethodBody | [DEFAULT AnnotationValue] ";")
  26.106 +     *      FormalParameters BracketsOpt [THROWS TypeList] ( MethodBody | [DEFAULT AnnotationValue] ";")
  26.107       *  VoidMethodDeclaratorRest =
  26.108 -     *      FormalParameters [Throws TypeList] ( MethodBody | ";")
  26.109 -     *  InterfaceMethodDeclaratorRest =
  26.110 -     *      FormalParameters BracketsOpt [THROWS TypeList] ";"
  26.111 -     *  VoidInterfaceMethodDeclaratorRest =
  26.112 -     *      FormalParameters [THROWS TypeList] ";"
  26.113 +     *      FormalParameters [THROWS TypeList] ( MethodBody | ";")
  26.114       *  ConstructorDeclaratorRest =
  26.115       *      "(" FormalParameterListOpt ")" [THROWS TypeList] MethodBody
  26.116       */
  26.117 @@ -4041,6 +4056,12 @@
  26.118              allowTypeAnnotations = true;
  26.119          }
  26.120      }
  26.121 +    void checkAnnotationsAfterTypeParams(int pos) {
  26.122 +        if (!allowAnnotationsAfterTypeParams) {
  26.123 +            log.error(pos, "annotations.after.type.params.not.supported.in.source", source.name);
  26.124 +            allowAnnotationsAfterTypeParams = true;
  26.125 +        }
  26.126 +    }
  26.127  
  26.128      /*
  26.129       * a functional source tree and end position mappings

    27.1 --- a/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Mon May 19 22:00:11 2014 -0700
    27.2 +++ b/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Thu May 29 13:46:36 2014 -0700
    27.3 @@ -762,14 +762,14 @@
    27.4          public Set<TypeElement> visitType(TypeElement e, Set<TypeElement> p) {
    27.5              // Type parameters are not considered to be enclosed by a type
    27.6              scan(e.getTypeParameters(), p);
    27.7 -            return scan(e.getEnclosedElements(), p);
    27.8 +            return super.visitType(e, p);
    27.9          }
   27.10  
   27.11          @Override
   27.12          public Set<TypeElement> visitExecutable(ExecutableElement e, Set<TypeElement> p) {
   27.13              // Type parameters are not considered to be enclosed by an executable
   27.14              scan(e.getTypeParameters(), p);
   27.15 -            return scan(e.getEnclosedElements(), p);
   27.16 +            return super.visitExecutable(e, p);
   27.17          }
   27.18  
   27.19          void addAnnotations(Element e, Set<TypeElement> p) {

    28.1 --- a/src/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java	Mon May 19 22:00:11 2014 -0700
    28.2 +++ b/src/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java	Thu May 29 13:46:36 2014 -0700
    28.3 @@ -1,5 +1,5 @@
    28.4  /*
    28.5 - * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
    28.6 + * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
    28.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    28.8   *
    28.9   * This code is free software; you can redistribute it and/or modify it
   28.10 @@ -26,11 +26,8 @@
   28.11  package com.sun.tools.javac.processing;
   28.12  
   28.13  import java.lang.annotation.Annotation;
   28.14 -import com.sun.tools.javac.tree.JCTree.*;
   28.15  import javax.annotation.processing.*;
   28.16  import javax.lang.model.element.*;
   28.17 -import javax.lang.model.type.DeclaredType;
   28.18 -import javax.lang.model.type.TypeMirror;
   28.19  import javax.lang.model.util.*;
   28.20  import java.util.*;
   28.21  
   28.22 @@ -114,58 +111,48 @@
   28.23       */
   28.24      public Set<? extends Element> getElementsAnnotatedWith(TypeElement a) {
   28.25          Set<Element> result = Collections.emptySet();
   28.26 -        Types typeUtil = processingEnv.getTypeUtils();
   28.27          if (a.getKind() != ElementKind.ANNOTATION_TYPE)
   28.28              throw new IllegalArgumentException(NOT_AN_ANNOTATION_TYPE + a);
   28.29  
   28.30 -        DeclaredType annotationTypeElement;
   28.31 -        TypeMirror tm = a.asType();
   28.32 -        if ( tm instanceof DeclaredType )
   28.33 -            annotationTypeElement = (DeclaredType) a.asType();
   28.34 -        else
   28.35 -            throw new AssertionError("Bad implementation type for " + tm);
   28.36 -
   28.37 -        ElementScanner8<Set<Element>, DeclaredType> scanner =
   28.38 -            new AnnotationSetScanner(result, typeUtil);
   28.39 +        ElementScanner8<Set<Element>, TypeElement> scanner =
   28.40 +            new AnnotationSetScanner(result);
   28.41  
   28.42          for (Element element : rootElements)
   28.43 -            result = scanner.scan(element, annotationTypeElement);
   28.44 +            result = scanner.scan(element, a);
   28.45  
   28.46          return result;
   28.47      }
   28.48  
   28.49      // Could be written as a local class inside getElementsAnnotatedWith
   28.50      private class AnnotationSetScanner extends
   28.51 -        ElementScanner8<Set<Element>, DeclaredType> {
   28.52 +        ElementScanner8<Set<Element>, TypeElement> {
   28.53          // Insertion-order preserving set
   28.54          Set<Element> annotatedElements = new LinkedHashSet<Element>();
   28.55 -        Types typeUtil;
   28.56  
   28.57 -        AnnotationSetScanner(Set<Element> defaultSet, Types typeUtil) {
   28.58 +        AnnotationSetScanner(Set<Element> defaultSet) {
   28.59              super(defaultSet);
   28.60 -            this.typeUtil = typeUtil;
   28.61          }
   28.62  
   28.63          @Override
   28.64 -        public Set<Element> visitType(TypeElement e, DeclaredType p) {
   28.65 +        public Set<Element> visitType(TypeElement e, TypeElement p) {
   28.66              // Type parameters are not considered to be enclosed by a type
   28.67              scan(e.getTypeParameters(), p);
   28.68 -            return scan(e.getEnclosedElements(), p);
   28.69 +            return super.visitType(e, p);
   28.70          }
   28.71  
   28.72          @Override
   28.73 -        public Set<Element> visitExecutable(ExecutableElement e, DeclaredType p) {
   28.74 +        public Set<Element> visitExecutable(ExecutableElement e, TypeElement p) {
   28.75              // Type parameters are not considered to be enclosed by an executable
   28.76              scan(e.getTypeParameters(), p);
   28.77 -            return scan(e.getEnclosedElements(), p);
   28.78 +            return super.visitExecutable(e, p);
   28.79          }
   28.80  
   28.81          @Override
   28.82 -        public Set<Element> scan(Element e, DeclaredType p) {
   28.83 +        public Set<Element> scan(Element e, TypeElement p) {
   28.84              java.util.List<? extends AnnotationMirror> annotationMirrors =
   28.85                  processingEnv.getElementUtils().getAllAnnotationMirrors(e);
   28.86              for (AnnotationMirror annotationMirror : annotationMirrors) {
   28.87 -                if (typeUtil.isSameType(annotationMirror.getAnnotationType(), p))
   28.88 +                if (p.equals(annotationMirror.getAnnotationType().asElement()))
   28.89                      annotatedElements.add(e);
   28.90              }
   28.91              e.accept(this, p);

    29.1 --- a/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Mon May 19 22:00:11 2014 -0700
    29.2 +++ b/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Thu May 29 13:46:36 2014 -0700
    29.3 @@ -1,5 +1,5 @@
    29.4  #
    29.5 -# Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    29.6 +# Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    29.7  # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    29.8  #
    29.9  # This code is free software; you can redistribute it and/or modify it
   29.10 @@ -123,6 +123,9 @@
   29.11  compiler.err.anon.class.impl.intf.no.qual.for.new=\
   29.12      anonymous class implements interface; cannot have qualifier for new
   29.13  
   29.14 +compiler.err.cant.inherit.from.anon=\
   29.15 +    cannot inherit from anonymous class
   29.16 +
   29.17  # 0: symbol, 1: symbol, 2: symbol
   29.18  compiler.err.array.and.varargs=\
   29.19      cannot declare both {0} and {1} in {2}
   29.20 @@ -732,6 +735,9 @@
   29.21      bad return type in method reference\n\
   29.22      {0}
   29.23  
   29.24 +compiler.err.lambda.body.neither.value.nor.void.compatible=\
   29.25 +    lambda body is neither value nor void compatible
   29.26 +
   29.27  # 0: list of type
   29.28  compiler.err.incompatible.thrown.types.in.mref=\
   29.29      incompatible thrown types {0} in method reference
   29.30 @@ -1611,6 +1617,10 @@
   29.31  compiler.warn.varargs.redundant.trustme.anno=\
   29.32      Redundant {0} annotation. {1}
   29.33  
   29.34 +# 0: symbol
   29.35 +compiler.warn.access.to.sensitive.member.from.serializable.element=\
   29.36 +    access to sensitive member {0} from serializable element can be publicly accessible to untrusted code
   29.37 +
   29.38  #####
   29.39  
   29.40  ## The following are tokens which are non-terminals in the language. They should
   29.41 @@ -1699,6 +1709,11 @@
   29.42      cannot access {0}\n\
   29.43      {1}
   29.44  
   29.45 +# 0: file name, 1: expected CP entry type, 2: constant pool index
   29.46 +compiler.misc.bad.const.pool.entry=\
   29.47 +    bad constant pool entry in {0}\n\
   29.48 +    expected {1} at index {2}
   29.49 +
   29.50  # 0: file name, 1: message segment
   29.51  compiler.misc.bad.class.file.header=\
   29.52      bad class file: {0}\n\
   29.53 @@ -2311,6 +2326,11 @@
   29.54  (use -source 8 or higher to enable type annotations)
   29.55  
   29.56  # 0: string
   29.57 +compiler.err.annotations.after.type.params.not.supported.in.source=\
   29.58 +    annotations after method type parameters are not supported in -source {0}\n\
   29.59 +(use -source 8 or higher to enable annotations after method type parameters)
   29.60 +
   29.61 +# 0: string
   29.62  compiler.err.repeatable.annotations.not.supported.in.source=\
   29.63      repeated annotations are not supported in -source {0}\n\
   29.64  (use -source 8 or higher to enable repeated annotations)

    30.1 --- a/src/share/classes/com/sun/tools/javac/resources/javac_ja.properties	Mon May 19 22:00:11 2014 -0700
    30.2 +++ b/src/share/classes/com/sun/tools/javac/resources/javac_ja.properties	Thu May 29 13:46:36 2014 -0700
    30.3 @@ -1,5 +1,5 @@
    30.4  #
    30.5 -# Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    30.6 +# Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    30.7  # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    30.8  #
    30.9  # This code is free software; you can redistribute it and/or modify it
   30.10 @@ -30,14 +30,14 @@
   30.11  javac.opt.g.lines.vars.source=\u3044\u304F\u3064\u304B\u306E\u30C7\u30D0\u30C3\u30B0\u60C5\u5831\u306E\u307F\u3092\u751F\u6210\u3059\u308B
   30.12  javac.opt.nowarn=\u8B66\u544A\u3092\u767A\u751F\u3055\u305B\u306A\u3044
   30.13  javac.opt.verbose=\u30B3\u30F3\u30D1\u30A4\u30E9\u306E\u52D5\u4F5C\u306B\u3064\u3044\u3066\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u51FA\u529B\u3059\u308B
   30.14 -javac.opt.deprecation=\u975E\u63A8\u5968\u306EAPI\u304C\u4F7F\u7528\u3055\u308C\u3066\u3044\u308B\u30BD\u30FC\u30B9\u306E\u4F4D\u7F6E\u3092\u51FA\u529B\u3059\u308B
   30.15 +javac.opt.deprecation=\u975E\u63A8\u5968\u306EAPI\u304C\u4F7F\u7528\u3055\u308C\u3066\u3044\u308B\u30BD\u30FC\u30B9\u306E\u5834\u6240\u3092\u51FA\u529B\u3059\u308B
   30.16  javac.opt.classpath=\u30E6\u30FC\u30B6\u30FC\u30FB\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304A\u3088\u3073\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u3092\u691C\u7D22\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B
   30.17  javac.opt.sourcepath=\u5165\u529B\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u691C\u7D22\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B
   30.18 -javac.opt.bootclasspath=\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306E\u4F4D\u7F6E\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B
   30.19 +javac.opt.bootclasspath=\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B
   30.20  javac.opt.Xbootclasspath.p=\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306B\u4ED8\u52A0\u3059\u308B
   30.21  javac.opt.Xbootclasspath.a=\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306B\u8FFD\u52A0\u3059\u308B
   30.22 -javac.opt.endorseddirs=\u63A8\u5968\u898F\u683C\u30D1\u30B9\u306E\u4F4D\u7F6E\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B
   30.23 -javac.opt.extdirs=\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u6E08\u307F\u62E1\u5F35\u6A5F\u80FD\u306E\u4F4D\u7F6E\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B
   30.24 +javac.opt.endorseddirs=\u63A8\u5968\u898F\u683C\u30D1\u30B9\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B
   30.25 +javac.opt.extdirs=\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u6E08\u307F\u62E1\u5F35\u6A5F\u80FD\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B
   30.26  javac.opt.processorpath=\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u3092\u691C\u7D22\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B
   30.27  javac.opt.processor=\u5B9F\u884C\u3059\u308B\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u306E\u540D\u524D\u3002\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u691C\u51FA\u51E6\u7406\u3092\u30D0\u30A4\u30D1\u30B9
   30.28  javac.opt.parameters=\u30E1\u30BD\u30C3\u30C9\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF\u306B\u30EA\u30D5\u30EC\u30AF\u30B7\u30E7\u30F3\u7528\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u751F\u6210\u3057\u307E\u3059
   30.29 @@ -133,7 +133,7 @@
   30.30  
   30.31  javac.msg.usage.nonstandard.footer=\u3053\u308C\u3089\u306F\u975E\u6A19\u6E96\u30AA\u30D7\u30B7\u30E7\u30F3\u3067\u3042\u308A\u4E88\u544A\u306A\u3057\u306B\u5909\u66F4\u3055\u308C\u308B\u3053\u3068\u304C\u3042\u308A\u307E\u3059\u3002
   30.32  
   30.33 -javac.msg.bug=\u30B3\u30F3\u30D1\u30A4\u30E9\u3067\u4F8B\u5916\u304C\u767A\u751F\u3057\u307E\u3057\u305F({0})\u3002Bug Parade\u306B\u540C\u3058\u30D0\u30B0\u304C\u767B\u9332\u3055\u308C\u3066\u3044\u306A\u3044\u3053\u3068\u3092\u3054\u78BA\u8A8D\u306E\u4E0A\u3001Java Developer Connection(http://java.sun.com/webapps/bugreport)\u3067\u30D0\u30B0\u306E\u767B\u9332\u3092\u304A\u9858\u3044\u3044\u305F\u3057\u307E\u3059\u3002\u30EC\u30DD\u30FC\u30C8\u306B\u306F\u3001\u305D\u306E\u30D7\u30ED\u30B0\u30E9\u30E0\u3068\u4E0B\u8A18\u306E\u8A3A\u65AD\u5185\u5BB9\u3092\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u3054\u5354\u529B\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002
   30.34 +javac.msg.bug=\u30B3\u30F3\u30D1\u30A4\u30E9\u3067\u4F8B\u5916\u304C\u767A\u751F\u3057\u307E\u3057\u305F({0})\u3002Bug Parade\u3067\u91CD\u8907\u304C\u306A\u3044\u304B\u3092\u3054\u78BA\u8A8D\u306E\u3046\u3048\u3001Java Developer Connection (http://java.sun.com/webapps/bugreport)\u3067bug\u306E\u767B\u9332\u3092\u304A\u9858\u3044\u3044\u305F\u3057\u307E\u3059\u3002\u30EC\u30DD\u30FC\u30C8\u306B\u306F\u3001\u305D\u306E\u30D7\u30ED\u30B0\u30E9\u30E0\u3068\u4E0B\u8A18\u306E\u8A3A\u65AD\u5185\u5BB9\u3092\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u3054\u5354\u529B\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002
   30.35  
   30.36  javac.msg.io=\n\n\u5165\u51FA\u529B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002\n\u8A73\u7D30\u306F\u6B21\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30C8\u30EC\u30FC\u30B9\u3067\u8ABF\u67FB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n
   30.37  

    31.1 --- a/src/share/classes/com/sun/tools/javac/sym/Profiles.java	Mon May 19 22:00:11 2014 -0700
    31.2 +++ b/src/share/classes/com/sun/tools/javac/sym/Profiles.java	Thu May 29 13:46:36 2014 -0700
    31.3 @@ -1,5 +1,5 @@
    31.4  /*
    31.5 - * Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
    31.6 + * Copyright (c) 2006, 2014, Oracle and/or its affiliates. All rights reserved.
    31.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    31.8   *
    31.9   * This code is free software; you can redistribute it and/or modify it
   31.10 @@ -153,6 +153,8 @@
   31.11          final int maxProfile = 4;  // Three compact profiles plus full JRE
   31.12  
   31.13          MakefileProfiles(Properties p) {
   31.14 +            // consider crypto, only if java/lang package exists
   31.15 +            boolean foundJavaLang = false;
   31.16              for (int profile = 1; profile <= maxProfile; profile++) {
   31.17                  String prefix = (profile < maxProfile ? "PROFILE_" + profile : "FULL_JRE");
   31.18                  String inclPackages = p.getProperty(prefix + "_RTJAR_INCLUDE_PACKAGES");
   31.19 @@ -161,6 +163,8 @@
   31.20                  for (String pkg: inclPackages.substring(1).trim().split("\\s+")) {
   31.21                      if (pkg.endsWith("/"))
   31.22                          pkg = pkg.substring(0, pkg.length() - 1);
   31.23 +                    if (foundJavaLang == false && pkg.equals("java/lang"))
   31.24 +                        foundJavaLang = true;
   31.25                      includePackage(profile, pkg);
   31.26                  }
   31.27                  String inclTypes =  p.getProperty(prefix + "_RTJAR_INCLUDE_TYPES");
   31.28 @@ -178,6 +182,15 @@
   31.29                      }
   31.30                  }
   31.31              }
   31.32 +            /*
   31.33 +             * A hack to force javax/crypto package into the compact1 profile,
   31.34 +             * because this package exists in jce.jar, and therefore not in
   31.35 +             * ct.sym. Note javax/crypto should exist in a profile along with
   31.36 +             * javax/net/ssl package. Thus, this package is added to compact1,
   31.37 +             * implying that it should exist in all three profiles.
   31.38 +             */
   31.39 +            if (foundJavaLang)
   31.40 +                includePackage(1, "javax/crypto");
   31.41          }
   31.42  
   31.43          @Override

    32.1 --- a/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Mon May 19 22:00:11 2014 -0700
    32.2 +++ b/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Thu May 29 13:46:36 2014 -0700
    32.3 @@ -609,6 +609,9 @@
    32.4              super.setPos(pos);
    32.5              return this;
    32.6          }
    32.7 +
    32.8 +        public boolean isPoly() { return false; }
    32.9 +        public boolean isStandalone() { return true; }
   32.10      }
   32.11  
   32.12      /**
   32.13 @@ -629,6 +632,9 @@
   32.14  
   32.15          /** is this poly expression a 'true' poly expression? */
   32.16          public PolyKind polyKind;
   32.17 +
   32.18 +        @Override public boolean isPoly() { return polyKind == PolyKind.POLY; }
   32.19 +        @Override public boolean isStandalone() { return polyKind == PolyKind.STANDALONE; }
   32.20      }
   32.21  
   32.22      /**

    33.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java	Mon May 19 22:00:11 2014 -0700
    33.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java	Thu May 29 13:46:36 2014 -0700
    33.3 @@ -1,5 +1,5 @@
    33.4  /*
    33.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    33.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    33.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    33.8   *
    33.9   * This code is free software; you can redistribute it and/or modify it
   33.10 @@ -831,6 +831,8 @@
   33.11              return symbol(((JCTypeApply) tree).clazz);
   33.12          case ANNOTATED_TYPE:
   33.13              return symbol(((JCAnnotatedType) tree).underlyingType);
   33.14 +        case REFERENCE:
   33.15 +            return ((JCMemberReference) tree).sym;
   33.16          default:
   33.17              return null;
   33.18          }

    34.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java	Mon May 19 22:00:11 2014 -0700
    34.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java	Thu May 29 13:46:36 2014 -0700
    34.3 @@ -1,5 +1,5 @@
    34.4  /*
    34.5 - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    34.6 + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
    34.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    34.8   *
    34.9   * This code is free software; you can redistribute it and/or modify it
   34.10 @@ -56,9 +56,9 @@
   34.11              return null;
   34.12          } else {
   34.13              tree.accept(this);
   34.14 -            JCTree result = this.result;
   34.15 +            JCTree tmpResult = this.result;
   34.16              this.result = null;
   34.17 -            return (T)result; // XXX cast
   34.18 +            return (T)tmpResult; // XXX cast
   34.19          }
   34.20      }
   34.21  

    35.1 --- a/src/share/classes/com/sun/tools/javadoc/JavadocTool.java	Mon May 19 22:00:11 2014 -0700
    35.2 +++ b/src/share/classes/com/sun/tools/javadoc/JavadocTool.java	Thu May 29 13:46:36 2014 -0700
    35.3 @@ -1,5 +1,5 @@
    35.4  /*
    35.5 - * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
    35.6 + * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
    35.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    35.8   *
    35.9   * This code is free software; you can redistribute it and/or modify it
   35.10 @@ -30,6 +30,7 @@
   35.11  import java.util.Collection;
   35.12  import java.util.EnumSet;
   35.13  import java.util.HashMap;
   35.14 +import java.util.HashSet;
   35.15  import java.util.Map;
   35.16  import java.util.Set;
   35.17  import javax.tools.JavaFileManager.Location;
   35.18 @@ -67,6 +68,7 @@
   35.19      final Messager messager;
   35.20      final JavadocClassReader javadocReader;
   35.21      final JavadocEnter javadocEnter;
   35.22 +    final Set<JavaFileObject> uniquefiles;
   35.23  
   35.24      /**
   35.25       * Construct a new JavaCompiler processor, using appropriately
   35.26 @@ -77,6 +79,7 @@
   35.27          messager = Messager.instance0(context);
   35.28          javadocReader = JavadocClassReader.instance0(context);
   35.29          javadocEnter = JavadocEnter.instance0(context);
   35.30 +        uniquefiles = new HashSet<>();
   35.31      }
   35.32  
   35.33      /**
   35.34 @@ -147,9 +150,7 @@
   35.35                  String name = it.head;
   35.36                  if (!docClasses && fm != null && name.endsWith(".java") && new File(name).exists()) {
   35.37                      JavaFileObject fo = fm.getJavaFileObjects(name).iterator().next();
   35.38 -                    docenv.notice("main.Loading_source_file", name);
   35.39 -                    JCCompilationUnit tree = parse(fo);
   35.40 -                    classTrees.append(tree);
   35.41 +                    parse(fo, classTrees, true);
   35.42                  } else if (isValidPackageName(name)) {
   35.43                      names = names.append(name);
   35.44                  } else if (name.endsWith(".java")) {
   35.45 @@ -162,9 +163,7 @@
   35.46                  }
   35.47              }
   35.48              for (JavaFileObject fo: fileObjects) {
   35.49 -                docenv.notice("main.Loading_source_file", fo.getName());
   35.50 -                JCCompilationUnit tree = parse(fo);
   35.51 -                classTrees.append(tree);
   35.52 +                parse(fo, classTrees, true);
   35.53              }
   35.54  
   35.55              if (!docClasses) {
   35.56 @@ -212,7 +211,7 @@
   35.57       * .java files found in such a directory to args.
   35.58       */
   35.59      private void parsePackageClasses(String name,
   35.60 -            Iterable<JavaFileObject> files,
   35.61 +            List<JavaFileObject> files,
   35.62              ListBuffer<JCCompilationUnit> trees,
   35.63              List<String> excludedPackages)
   35.64              throws IOException {
   35.65 @@ -220,7 +219,6 @@
   35.66              return;
   35.67          }
   35.68  
   35.69 -        boolean hasFiles = false;
   35.70          docenv.notice("main.Loading_source_files_for_package", name);
   35.71  
   35.72          if (files == null) {
   35.73 @@ -237,16 +235,22 @@
   35.74              }
   35.75              files = lb.toList();
   35.76          }
   35.77 +        if (files.nonEmpty()) {
   35.78 +            for (JavaFileObject fo : files) {
   35.79 +                parse(fo, trees, false);
   35.80 +            }
   35.81 +        } else {
   35.82 +            messager.warning(Messager.NOPOS, "main.no_source_files_for_package",
   35.83 +                             name.replace(File.separatorChar, '.'));
   35.84 +        }
   35.85 +    }
   35.86  
   35.87 -        for (JavaFileObject fo : files) {
   35.88 -            // messager.notice("main.Loading_source_file", fn);
   35.89 +    private void parse(JavaFileObject fo, ListBuffer<JCCompilationUnit> trees,
   35.90 +                       boolean trace) {
   35.91 +        if (uniquefiles.add(fo)) { // ignore duplicates
   35.92 +            if (trace)
   35.93 +                docenv.notice("main.Loading_source_file", fo.getName());
   35.94              trees.append(parse(fo));
   35.95 -            hasFiles = true;
   35.96 -        }
   35.97 -
   35.98 -        if (!hasFiles) {
   35.99 -            messager.warning(Messager.NOPOS, "main.no_source_files_for_package",
  35.100 -                    name.replace(File.separatorChar, '.'));
  35.101          }
  35.102      }
  35.103  

    36.1 --- a/src/share/classes/com/sun/tools/javap/AttributeWriter.java	Mon May 19 22:00:11 2014 -0700
    36.2 +++ b/src/share/classes/com/sun/tools/javap/AttributeWriter.java	Thu May 29 13:46:36 2014 -0700
    36.3 @@ -226,10 +226,7 @@
    36.4      }
    36.5  
    36.6      public Void visitConstantValue(ConstantValue_attribute attr, Void ignore) {
    36.7 -        if (options.compat) // BUG 6622216 javap names some attributes incorrectly
    36.8 -            print("Constant value: ");
    36.9 -        else
   36.10 -            print("ConstantValue: ");
   36.11 +        print("ConstantValue: ");
   36.12          constantWriter.write(attr.constantvalue_index);
   36.13          println();
   36.14          return null;
   36.15 @@ -290,20 +287,10 @@
   36.16  
   36.17      public Void visitInnerClasses(InnerClasses_attribute attr, Void ignore) {
   36.18          boolean first = true;
   36.19 -        if (options.compat) {
   36.20 -            writeInnerClassHeader();
   36.21 -            first = false;
   36.22 -        }
   36.23          for (int i = 0 ; i < attr.classes.length; i++) {
   36.24              InnerClasses_attribute.Info info = attr.classes[i];
   36.25              //access
   36.26              AccessFlags access_flags = info.inner_class_access_flags;
   36.27 -            if (options.compat) {
   36.28 -                // BUG 6622215: javap ignores certain relevant access flags
   36.29 -                access_flags = access_flags.ignore(ACC_STATIC | ACC_PROTECTED | ACC_PRIVATE | ACC_INTERFACE | ACC_SYNTHETIC | ACC_ENUM);
   36.30 -                // BUG 6622232: javap gets whitespace confused
   36.31 -                print("   ");
   36.32 -            }
   36.33              if (options.checkAccess(access_flags)) {
   36.34                  if (first) {
   36.35                      writeInnerClassHeader();
   36.36 @@ -345,11 +332,7 @@
   36.37      }
   36.38  
   36.39      private void writeInnerClassHeader() {
   36.40 -        if (options.compat) // BUG 6622216: javap names some attributes incorrectly
   36.41 -            print("InnerClass");
   36.42 -        else
   36.43 -            print("InnerClasses");
   36.44 -        println(":");
   36.45 +        println("InnerClasses:");
   36.46          indent(+1);
   36.47      }
   36.48  
   36.49 @@ -547,7 +530,6 @@
   36.50          for (StackMapTable_attribute.stack_map_frame entry : attr.entries) {
   36.51              w.write(entry);
   36.52          }
   36.53 -        println();
   36.54          indent(-1);
   36.55          return null;
   36.56      }
   36.57 @@ -559,7 +541,6 @@
   36.58          for (StackMapTable_attribute.stack_map_frame entry : attr.entries) {
   36.59              w.write(entry);
   36.60          }
   36.61 -        println();
   36.62          indent(-1);
   36.63          return null;
   36.64      }
   36.65 @@ -571,14 +552,12 @@
   36.66          }
   36.67  
   36.68          public Void visit_same_frame(StackMapTable_attribute.same_frame frame, Void p) {
   36.69 -            printHeader(frame);
   36.70 -            println(" /* same */");
   36.71 +            printHeader(frame, "/* same */");
   36.72              return null;
   36.73          }
   36.74  
   36.75          public Void visit_same_locals_1_stack_item_frame(StackMapTable_attribute.same_locals_1_stack_item_frame frame, Void p) {
   36.76 -            printHeader(frame);
   36.77 -            println(" /* same_locals_1_stack_item */");
   36.78 +            printHeader(frame, "/* same_locals_1_stack_item */");
   36.79              indent(+1);
   36.80              printMap("stack", frame.stack);
   36.81              indent(-1);
   36.82 @@ -586,8 +565,7 @@
   36.83          }
   36.84  
   36.85          public Void visit_same_locals_1_stack_item_frame_extended(StackMapTable_attribute.same_locals_1_stack_item_frame_extended frame, Void p) {
   36.86 -            printHeader(frame);
   36.87 -            println(" /* same_locals_1_stack_item_frame_extended */");
   36.88 +            printHeader(frame, "/* same_locals_1_stack_item_frame_extended */");
   36.89              indent(+1);
   36.90              println("offset_delta = " + frame.offset_delta);
   36.91              printMap("stack", frame.stack);
   36.92 @@ -596,8 +574,7 @@
   36.93          }
   36.94  
   36.95          public Void visit_chop_frame(StackMapTable_attribute.chop_frame frame, Void p) {
   36.96 -            printHeader(frame);
   36.97 -            println(" /* chop */");
   36.98 +            printHeader(frame, "/* chop */");
   36.99              indent(+1);
  36.100              println("offset_delta = " + frame.offset_delta);
  36.101              indent(-1);
  36.102 @@ -605,8 +582,7 @@
  36.103          }
  36.104  
  36.105          public Void visit_same_frame_extended(StackMapTable_attribute.same_frame_extended frame, Void p) {
  36.106 -            printHeader(frame);
  36.107 -            println(" /* same_frame_extended */");
  36.108 +            printHeader(frame, "/* same_frame_extended */");
  36.109              indent(+1);
  36.110              println("offset_delta = " + frame.offset_delta);
  36.111              indent(-1);
  36.112 @@ -614,21 +590,20 @@
  36.113          }
  36.114  
  36.115          public Void visit_append_frame(StackMapTable_attribute.append_frame frame, Void p) {
  36.116 -            printHeader(frame);
  36.117 -            println(" /* append */");
  36.118 +            printHeader(frame, "/* append */");
  36.119              indent(+1);
  36.120              println("offset_delta = " + frame.offset_delta);
  36.121              printMap("locals", frame.locals);
  36.122 +            indent(-1);
  36.123              return null;
  36.124          }
  36.125  
  36.126          public Void visit_full_frame(StackMapTable_attribute.full_frame frame, Void p) {
  36.127 -            printHeader(frame);
  36.128              if (frame instanceof StackMap_attribute.stack_map_frame) {
  36.129 +                printHeader(frame, "offset = " + frame.offset_delta);
  36.130                  indent(+1);
  36.131 -                println(" offset = " + frame.offset_delta);
  36.132              } else {
  36.133 -                println(" /* full_frame */");
  36.134 +                printHeader(frame, "/* full_frame */");
  36.135                  indent(+1);
  36.136                  println("offset_delta = " + frame.offset_delta);
  36.137              }
  36.138 @@ -638,8 +613,9 @@
  36.139              return null;
  36.140          }
  36.141  
  36.142 -        void printHeader(StackMapTable_attribute.stack_map_frame frame) {
  36.143 -            print("   frame_type = " + frame.frame_type);
  36.144 +        void printHeader(StackMapTable_attribute.stack_map_frame frame, String extra) {
  36.145 +            print("frame_type = " + frame.frame_type + " ");
  36.146 +            println(extra);
  36.147          }
  36.148  
  36.149          void printMap(String name, StackMapTable_attribute.verification_type_info[] map) {
  36.150 @@ -710,10 +686,7 @@
  36.151      }
  36.152  
  36.153      String toHex(byte b, int w) {
  36.154 -        if (options.compat) // BUG 6622260: javap prints negative bytes incorrectly in hex
  36.155 -            return toHex((int) b, w);
  36.156 -        else
  36.157 -            return toHex(b & 0xff, w);
  36.158 +        return toHex(b & 0xff, w);
  36.159      }
  36.160  
  36.161      static String toHex(int i) {