Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/README	Thu Sep 12 11:09:20 2013 -0700
     1.2 +++ b/README	Tue Sep 17 08:21:11 2013 -0700
     1.3 @@ -32,7 +32,7 @@
     1.4  JLS and JVMS.
     1.5  
     1.6  In addition, there is a substantial collection of regression and unit
     1.7 -tests for all the tools in the maain langtools test/ directory.
     1.8 +tests for all the tools in the main langtools test/ directory.
     1.9  
    1.10  Finally, there is a small set of tests to do basic validation of a build
    1.11  of the langtools workspace for use by JDK. These tests check the contents

     2.1 --- a/make/netbeans/langtools/build.xml	Thu Sep 12 11:09:20 2013 -0700
     2.2 +++ b/make/netbeans/langtools/build.xml	Tue Sep 17 08:21:11 2013 -0700
     2.3 @@ -1,6 +1,6 @@
     2.4  <?xml version="1.0" encoding="UTF-8"?>
     2.5  <!--
     2.6 - Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
     2.7 + Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
     2.8  
     2.9   Redistribution and use in source and binary forms, with or without
    2.10   modification, are permitted provided that the following conditions
    2.11 @@ -55,10 +55,18 @@
    2.12          description="Build one or all langtools tools"
    2.13          />
    2.14  
    2.15 +    <condition property="bootstrap" value="bootstrap-" else="">
    2.16 +        <isset property="langtools.tool.bootstrap"/>
    2.17 +    </condition>
    2.18 +
    2.19 +    <condition property="bcp" value="${build.bootstrap.dir}/classes" else="${build.classes.dir}">
    2.20 +        <isset property="langtools.tool.bootstrap"/>
    2.21 +    </condition>
    2.22 +
    2.23      <target name="-build-tool" if="langtools.tool.name">
    2.24 -        <echo level="info" message="Building ${langtools.tool.name}"/>
    2.25 +        <echo level="info" message="Building ${bootstrap}${langtools.tool.name}"/>
    2.26          <echo level="verbose" message="(Unset langtools.tool.name to build all tools)"/>
    2.27 -        <antcall target="build-${langtools.tool.name}"/>
    2.28 +        <antcall target="build-${bootstrap}${langtools.tool.name}"/>
    2.29      </target>
    2.30  
    2.31      <target name="-build-all" unless="langtools.tool.name">
    2.32 @@ -89,8 +97,9 @@
    2.33  
    2.34      <target name="run" depends="-check-target.java.home,build,-def-run,-get-tool-and-args"
    2.35              description="run tool">
    2.36 -        <echo level="info" message="Run ${langtools.tool.name} with args ${langtools.tool.args}"/>
    2.37 -        <run mainclass="com.sun.tools.${langtools.tool.name}.Main" args="${langtools.tool.args}"/>
    2.38 +        <echo level="info" message="${bcp}"/>
    2.39 +        <echo level="info" message="Run ${bootstrap}${langtools.tool.name} with args ${langtools.tool.args}"/>
    2.40 +        <run bcp="${bcp}" mainclass="com.sun.tools.${langtools.tool.name}.Main" args="${langtools.tool.args}"/>
    2.41      </target>
    2.42  
    2.43      <!-- Run a selected class. (action: run.single;  shift-F6) -->
    2.44 @@ -136,9 +145,9 @@
    2.45      <!-- Debug tool in NetBeans. -->
    2.46  
    2.47      <target name="debug" depends="-check-target.java.home,-def-run,-def-start-debugger,-get-tool-and-args,build" if="netbeans.home">
    2.48 -        <echo level="info" message="Debug ${langtools.tool.name} with args ${langtools.tool.args}"/>
    2.49 +        <echo level="info" message="Debug ${boostrap}${langtools.tool.name} with args ${langtools.tool.args}"/>
    2.50          <start-debugger/>
    2.51 -        <run mainclass="com.sun.tools.${langtools.tool.name}.Main" args="${langtools.tool.args}" jpda.jvmargs="${jpda.jvmargs}"/>
    2.52 +        <run bcp="${bcp}" mainclass="com.sun.tools.${langtools.tool.name}.Main" args="${langtools.tool.args}" jpda.jvmargs="${jpda.jvmargs}"/>
    2.53      </target>
    2.54  
    2.55      <!-- Debug a selected class . -->
    2.56 @@ -207,6 +216,7 @@
    2.57      <target name="-get-tool-if-set" depends="-def-select-tool">
    2.58          <select-tool
    2.59              toolproperty="langtools.tool.name"
    2.60 +            bootstrapproperty="langtools.tool.bootstrap"
    2.61              propertyfile="${langtools.properties}"
    2.62              askIfUnset="false"
    2.63              />
    2.64 @@ -216,6 +226,7 @@
    2.65          <select-tool
    2.66              toolproperty="langtools.tool.name"
    2.67              argsproperty="langtools.tool.args"
    2.68 +            bootstrapproperty="langtools.tool.bootstrap"
    2.69              propertyfile="${langtools.properties}"
    2.70              askIfUnset="true"
    2.71              />
    2.72 @@ -226,10 +237,12 @@
    2.73          <macrodef name="run">
    2.74              <attribute name="mainclass"/>
    2.75              <attribute name="args" default=""/>
    2.76 +            <attribute name="bcp" default="${build.classes.dir}"/>
    2.77              <attribute name="jpda.jvmargs" default=""/>
    2.78 +
    2.79              <sequential>
    2.80                  <java fork="true" jvm="${target.java}" classname="@{mainclass}">
    2.81 -                    <jvmarg line="-Xbootclasspath/p:${build.classes.dir}"/>
    2.82 +                    <jvmarg line="-Xbootclasspath/p:${bcp}"/>
    2.83                      <jvmarg line="@{jpda.jvmargs}"/>
    2.84                      <arg line="@{args}"/>
    2.85                  </java>

     3.1 --- a/make/tools/anttasks/SelectToolTask.java	Thu Sep 12 11:09:20 2013 -0700
     3.2 +++ b/make/tools/anttasks/SelectToolTask.java	Tue Sep 17 08:21:11 2013 -0700
     3.3 @@ -1,5 +1,5 @@
     3.4  /*
     3.5 - * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
     3.6 + * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
     3.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3.8   *
     3.9   * This code is free software; you can redistribute it and/or modify it
    3.10 @@ -43,6 +43,7 @@
    3.11  import java.io.Writer;
    3.12  import java.util.ArrayList;
    3.13  import java.util.Arrays;
    3.14 +import java.util.EnumSet;
    3.15  import java.util.List;
    3.16  import java.util.Properties;
    3.17  import javax.swing.JButton;
    3.18 @@ -71,6 +72,31 @@
    3.19   * is invoked to allow the user to set or reset values for use in property mode.
    3.20   */
    3.21  public class SelectToolTask extends Task {
    3.22 +
    3.23 +    enum ToolChoices {
    3.24 +        NONE(""),
    3.25 +        JAVAC("javac"),
    3.26 +        JAVADOC("javadoc"),
    3.27 +        JAVAH("javah"),
    3.28 +        JAVAP("javap");
    3.29 +
    3.30 +        String toolName;
    3.31 +        boolean bootstrap;
    3.32 +
    3.33 +        ToolChoices(String toolName) {
    3.34 +            this(toolName, false);
    3.35 +        }
    3.36 +
    3.37 +        ToolChoices(String toolName, boolean boostrap) {
    3.38 +            this.toolName = toolName;
    3.39 +        }
    3.40 +
    3.41 +        @Override
    3.42 +        public String toString() {
    3.43 +            return toolName;
    3.44 +        }
    3.45 +    }
    3.46 +
    3.47      /**
    3.48       * Set the location of the private properties file used to keep the retain
    3.49       * user preferences for this repository.
    3.50 @@ -97,6 +123,14 @@
    3.51      }
    3.52  
    3.53      /**
    3.54 +     * Set the name of the property which will be set to the execution args of the
    3.55 +     * selected tool, if any. The args default to an empty string.
    3.56 +     */
    3.57 +    public void setBootstrapProperty(String bootstrapProperty) {
    3.58 +        this.bootstrapProperty = bootstrapProperty;
    3.59 +    }
    3.60 +
    3.61 +    /**
    3.62       * Specify whether or not to pop up a dialog if the user has not specified
    3.63       * a default value for a property.
    3.64       */
    3.65 @@ -110,6 +144,7 @@
    3.66  
    3.67          Properties props = readProperties(propertyFile);
    3.68          toolName = props.getProperty("tool.name");
    3.69 +        toolBootstrap = props.getProperty("tool.bootstrap") != null;
    3.70          if (toolName != null) {
    3.71              toolArgs = props.getProperty(toolName + ".args", "");
    3.72          }
    3.73 @@ -123,6 +158,8 @@
    3.74          // finally, return required values, if any
    3.75          if (toolProperty != null && !(toolName == null || toolName.equals(""))) {
    3.76              p.setProperty(toolProperty, toolName);
    3.77 +            if (toolBootstrap)
    3.78 +                p.setProperty(bootstrapProperty, "true");
    3.79  
    3.80              if (argsProperty != null && toolArgs != null)
    3.81                  p.setProperty(argsProperty, toolArgs);
    3.82 @@ -134,14 +171,20 @@
    3.83          JOptionPane p = createPane(guiProps);
    3.84          p.createDialog("Select Tool").setVisible(true);
    3.85  
    3.86 -        toolName = (String) toolChoice.getSelectedItem();
    3.87 +        toolName = ((ToolChoices)toolChoice.getSelectedItem()).toolName;
    3.88          toolArgs = argsField.getText();
    3.89 -
    3.90 +        toolBootstrap = bootstrapCheckbox.isSelected();
    3.91          if (defaultCheck.isSelected()) {
    3.92              if (toolName.equals("")) {
    3.93                  fileProps.remove("tool.name");
    3.94 +                fileProps.remove("tool.bootstrap");
    3.95              } else {
    3.96                  fileProps.put("tool.name", toolName);
    3.97 +                if (toolBootstrap) {
    3.98 +                    fileProps.put("tool.bootstrap", "true");
    3.99 +                } else {
   3.100 +                    fileProps.remove("tool.bootstrap");
   3.101 +                }
   3.102                  fileProps.put(toolName + ".args", toolArgs);
   3.103              }
   3.104              writeProperties(propertyFile, fileProps);
   3.105 @@ -154,32 +197,38 @@
   3.106          lc.insets.right = 10;
   3.107          lc.insets.bottom = 3;
   3.108          GridBagConstraints fc = new GridBagConstraints();
   3.109 -        fc.anchor = GridBagConstraints.WEST;
   3.110          fc.gridx = 1;
   3.111 -        fc.gridwidth = GridBagConstraints.REMAINDER;
   3.112 +        fc.gridwidth = GridBagConstraints.NONE;
   3.113          fc.insets.bottom = 3;
   3.114  
   3.115 +        JPanel toolPane = new JPanel(new GridBagLayout());
   3.116 +
   3.117          JLabel toolLabel = new JLabel("Tool:");
   3.118          body.add(toolLabel, lc);
   3.119 -        String[] toolChoices = { "apt", "javac", "javadoc", "javah", "javap" };
   3.120 -        if (true || toolProperty == null) {
   3.121 -            // include empty value in setup mode
   3.122 -            List<String> l = new ArrayList<String>(Arrays.asList(toolChoices));
   3.123 -            l.add(0, "");
   3.124 -            toolChoices = l.toArray(new String[l.size()]);
   3.125 -        }
   3.126 -        toolChoice = new JComboBox(toolChoices);
   3.127 +        EnumSet<ToolChoices> toolChoices = toolProperty == null ?
   3.128 +                EnumSet.allOf(ToolChoices.class) : EnumSet.range(ToolChoices.JAVAC, ToolChoices.JAVAP);
   3.129 +        toolChoice = new JComboBox(toolChoices.toArray());
   3.130          if (toolName != null)
   3.131 -            toolChoice.setSelectedItem(toolName);
   3.132 +            toolChoice.setSelectedItem(ToolChoices.valueOf(toolName.toUpperCase()));
   3.133          toolChoice.addItemListener(new ItemListener() {
   3.134              public void itemStateChanged(ItemEvent e) {
   3.135 -                String tn = (String) e.getItem();
   3.136 +                String tn = ((ToolChoices)e.getItem()).toolName;
   3.137                  argsField.setText(getDefaultArgsForTool(props, tn));
   3.138                  if (toolProperty != null)
   3.139                      okButton.setEnabled(!tn.equals(""));
   3.140              }
   3.141          });
   3.142 -        body.add(toolChoice, fc);
   3.143 +        GridBagConstraints checkConstraint = new GridBagConstraints();
   3.144 +        fc.anchor = GridBagConstraints.EAST;
   3.145 +
   3.146 +        GridBagConstraints toolConstraint = new GridBagConstraints();
   3.147 +        fc.anchor = GridBagConstraints.WEST;
   3.148 +
   3.149 +        toolPane.add(toolChoice, toolConstraint);
   3.150 +        bootstrapCheckbox = new JCheckBox("bootstrap", toolBootstrap);
   3.151 +        toolPane.add(bootstrapCheckbox, checkConstraint);
   3.152 +
   3.153 +        body.add(toolPane, fc);
   3.154  
   3.155          argsField = new JTextField(getDefaultArgsForTool(props, toolName), 40);
   3.156          if (toolProperty == null || argsProperty != null) {
   3.157 @@ -190,7 +239,7 @@
   3.158                  public void focusGained(FocusEvent e) {
   3.159                  }
   3.160                  public void focusLost(FocusEvent e) {
   3.161 -                    String toolName = (String) toolChoice.getSelectedItem();
   3.162 +                    String toolName = ((ToolChoices)toolChoice.getSelectedItem()).toolName;
   3.163                      if (toolName.length() > 0)
   3.164                          props.put(toolName + ".args", argsField.getText());
   3.165                  }
   3.166 @@ -271,16 +320,19 @@
   3.167      // Ant task parameters
   3.168      private boolean askIfUnset;
   3.169      private String toolProperty;
   3.170 +    private String bootstrapProperty;
   3.171      private String argsProperty;
   3.172      private File propertyFile;
   3.173  
   3.174      // GUI components
   3.175      private JComboBox toolChoice;
   3.176 +    private JCheckBox bootstrapCheckbox;
   3.177      private JTextField argsField;
   3.178      private JCheckBox defaultCheck;
   3.179      private JButton okButton;
   3.180  
   3.181      // Result values for the client
   3.182      private String toolName;
   3.183 +    private boolean toolBootstrap;
   3.184      private String toolArgs;
   3.185  }

     4.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/AbstractPackageIndexWriter.java	Thu Sep 12 11:09:20 2013 -0700
     4.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/AbstractPackageIndexWriter.java	Tue Sep 17 08:21:11 2013 -0700
     4.3 @@ -157,7 +157,7 @@
     4.4                  addAllProfilesLink(div);
     4.5              }
     4.6              body.addContent(div);
     4.7 -            if (configuration.showProfiles) {
     4.8 +            if (configuration.showProfiles && configuration.profilePackages.size() > 0) {
     4.9                  Content profileSummary = configuration.getResource("doclet.Profiles");
    4.10                  addProfilesList(profileSummary, body);
    4.11              }

     5.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/AnnotationTypeWriterImpl.java	Thu Sep 12 11:09:20 2013 -0700
     5.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/AnnotationTypeWriterImpl.java	Tue Sep 17 08:21:11 2013 -0700
     5.3 @@ -118,7 +118,7 @@
     5.4          if (prev != null) {
     5.5              Content prevLink = getLink(new LinkInfoImpl(configuration,
     5.6                      LinkInfoImpl.Kind.CLASS, prev.asClassDoc())
     5.7 -                    .label(configuration.getText("doclet.Prev_Class")).strong(true));
     5.8 +                    .label(prevclassLabel).strong(true));
     5.9              li = HtmlTree.LI(prevLink);
    5.10          }
    5.11          else
    5.12 @@ -136,7 +136,7 @@
    5.13          if (next != null) {
    5.14              Content nextLink = getLink(new LinkInfoImpl(configuration,
    5.15                      LinkInfoImpl.Kind.CLASS, next.asClassDoc())
    5.16 -                    .label(configuration.getText("doclet.Next_Class")).strong(true));
    5.17 +                    .label(nextclassLabel).strong(true));
    5.18              li = HtmlTree.LI(nextLink);
    5.19          }
    5.20          else

     6.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java	Thu Sep 12 11:09:20 2013 -0700
     6.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java	Tue Sep 17 08:21:11 2013 -0700
     6.3 @@ -126,7 +126,7 @@
     6.4          if (prev != null) {
     6.5              Content prevLink = getLink(new LinkInfoImpl(configuration,
     6.6                      LinkInfoImpl.Kind.CLASS, prev)
     6.7 -                    .label(configuration.getText("doclet.Prev_Class")).strong(true));
     6.8 +                    .label(prevclassLabel).strong(true));
     6.9              li = HtmlTree.LI(prevLink);
    6.10          }
    6.11          else
    6.12 @@ -144,7 +144,7 @@
    6.13          if (next != null) {
    6.14              Content nextLink = getLink(new LinkInfoImpl(configuration,
    6.15                      LinkInfoImpl.Kind.CLASS, next)
    6.16 -                    .label(configuration.getText("doclet.Next_Class")).strong(true));
    6.17 +                    .label(nextclassLabel).strong(true));
    6.18              li = HtmlTree.LI(nextLink);
    6.19          }
    6.20          else

     7.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDoclet.java	Thu Sep 12 11:09:20 2013 -0700
     7.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDoclet.java	Tue Sep 17 08:21:11 2013 -0700
     7.3 @@ -205,13 +205,20 @@
     7.4       * {@inheritDoc}
     7.5       */
     7.6      protected void generateProfileFiles() throws Exception {
     7.7 -        if (configuration.showProfiles) {
     7.8 +        if (configuration.showProfiles && configuration.profilePackages.size() > 0) {
     7.9              ProfileIndexFrameWriter.generate(configuration);
    7.10              Profile prevProfile = null, nextProfile;
    7.11 +            String profileName;
    7.12              for (int i = 1; i < configuration.profiles.getProfileCount(); i++) {
    7.13 -                ProfilePackageIndexFrameWriter.generate(configuration, Profile.lookup(i).name);
    7.14 +                profileName = Profile.lookup(i).name;
    7.15 +                // Generate profile package pages only if there are any packages
    7.16 +                // in a profile to be documented. The profilePackages map will not
    7.17 +                // contain an entry for the profile if there are no packages to be documented.
    7.18 +                if (!configuration.shouldDocumentProfile(profileName))
    7.19 +                    continue;
    7.20 +                ProfilePackageIndexFrameWriter.generate(configuration, profileName);
    7.21                  PackageDoc[] packages = configuration.profilePackages.get(
    7.22 -                        Profile.lookup(i).name);
    7.23 +                        profileName);
    7.24                  PackageDoc prev = null, next;
    7.25                  for (int j = 0; j < packages.length; j++) {
    7.26                      // if -nodeprecated option is set and the package is marked as

     8.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java	Thu Sep 12 11:09:20 2013 -0700
     8.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java	Tue Sep 17 08:21:11 2013 -0700
     8.3 @@ -406,10 +406,7 @@
     8.4          Content htmlDocType = DocType.TRANSITIONAL;
     8.5          Content htmlComment = new Comment(configuration.getText("doclet.New_Page"));
     8.6          Content head = new HtmlTree(HtmlTag.HEAD);
     8.7 -        if (!configuration.notimestamp) {
     8.8 -            Content headComment = new Comment(getGeneratedByString());
     8.9 -            head.addContent(headComment);
    8.10 -        }
    8.11 +        head.addContent(getGeneratedBy(!configuration.notimestamp));
    8.12          if (configuration.charset.length() > 0) {
    8.13              Content meta = HtmlTree.META("Content-Type", CONTENT_TYPE,
    8.14                      configuration.charset);
    8.15 @@ -502,16 +499,17 @@
    8.16          if (!configuration.nonavbar) {
    8.17              String allClassesId = "allclasses_";
    8.18              HtmlTree navDiv = new HtmlTree(HtmlTag.DIV);
    8.19 +            Content skipNavLinks = configuration.getResource("doclet.Skip_navigation_links");
    8.20              if (header) {
    8.21                  body.addContent(HtmlConstants.START_OF_TOP_NAVBAR);
    8.22                  navDiv.addStyle(HtmlStyle.topNav);
    8.23                  allClassesId += "navbar_top";
    8.24                  Content a = getMarkerAnchor("navbar_top");
    8.25 +                //WCAG - Hyperlinks should contain text or an image with alt text - for AT tools
    8.26                  navDiv.addContent(a);
    8.27 -                Content skipLinkContent = getHyperLink(DocLink.fragment("skip-navbar_top"),
    8.28 -                        HtmlTree.EMPTY,
    8.29 -                        configuration.getText("doclet.Skip_navigation_links"),
    8.30 -                        "");
    8.31 +                Content skipLinkContent = HtmlTree.DIV(HtmlStyle.skipNav, getHyperLink(
    8.32 +                    DocLink.fragment("skip-navbar_top"), skipNavLinks,
    8.33 +                    skipNavLinks.toString(), ""));
    8.34                  navDiv.addContent(skipLinkContent);
    8.35              } else {
    8.36                  body.addContent(HtmlConstants.START_OF_BOTTOM_NAVBAR);
    8.37 @@ -519,10 +517,9 @@
    8.38                  allClassesId += "navbar_bottom";
    8.39                  Content a = getMarkerAnchor("navbar_bottom");
    8.40                  navDiv.addContent(a);
    8.41 -                Content skipLinkContent = getHyperLink(DocLink.fragment("skip-navbar_bottom"),
    8.42 -                        HtmlTree.EMPTY,
    8.43 -                        configuration.getText("doclet.Skip_navigation_links"),
    8.44 -                        "");
    8.45 +                Content skipLinkContent = HtmlTree.DIV(HtmlStyle.skipNav, getHyperLink(
    8.46 +                    DocLink.fragment("skip-navbar_bottom"), skipNavLinks,
    8.47 +                    skipNavLinks.toString(), ""));
    8.48                  navDiv.addContent(skipLinkContent);
    8.49              }
    8.50              if (header) {

     9.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java	Thu Sep 12 11:09:20 2013 -0700
     9.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java	Tue Sep 17 08:21:11 2013 -0700
     9.3 @@ -130,10 +130,14 @@
     9.4          String profileName;
     9.5          for (int i = 1; i < configuration.profiles.getProfileCount(); i++) {
     9.6              profileName = Profile.lookup(i).name;
     9.7 -            Content profileLinkContent = getTargetProfileLink("classFrame",
     9.8 -                    new StringContent(profileName), profileName);
     9.9 -            Content li = HtmlTree.LI(profileLinkContent);
    9.10 -            ul.addContent(li);
    9.11 +            // If the profile has valid packages to be documented, add it to the
    9.12 +            // profiles list on overview-summary.html page.
    9.13 +            if (configuration.shouldDocumentProfile(profileName)) {
    9.14 +                Content profileLinkContent = getTargetProfileLink("classFrame",
    9.15 +                        new StringContent(profileName), profileName);
    9.16 +                Content li = HtmlTree.LI(profileLinkContent);
    9.17 +                ul.addContent(li);
    9.18 +            }
    9.19          }
    9.20          profilesDiv.addContent(ul);
    9.21          Content div = HtmlTree.DIV(HtmlStyle.contentContainer, profilesDiv);

    10.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/ProfileIndexFrameWriter.java	Thu Sep 12 11:09:20 2013 -0700
    10.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/ProfileIndexFrameWriter.java	Tue Sep 17 08:21:11 2013 -0700
    10.3 @@ -88,8 +88,13 @@
    10.4          Content div = HtmlTree.DIV(HtmlStyle.indexContainer, heading);
    10.5          HtmlTree ul = new HtmlTree(HtmlTag.UL);
    10.6          ul.setTitle(profilesLabel);
    10.7 +        String profileName;
    10.8          for (int i = 1; i < profiles.getProfileCount(); i++) {
    10.9 -            ul.addContent(getProfile(i));
   10.10 +            profileName = (Profile.lookup(i)).name;
   10.11 +            // If the profile has valid packages to be documented, add it to the
   10.12 +            // left-frame generated for profile index.
   10.13 +            if (configuration.shouldDocumentProfile(profileName))
   10.14 +                ul.addContent(getProfile(profileName));
   10.15          }
   10.16          div.addContent(ul);
   10.17          body.addContent(div);
   10.18 @@ -98,13 +103,12 @@
   10.19      /**
   10.20       * Gets each profile name as a separate link.
   10.21       *
   10.22 -     * @param profile the profile being documented
   10.23 +     * @param profileName the profile being documented
   10.24       * @return content for the profile link
   10.25       */
   10.26 -    protected Content getProfile(int profile) {
   10.27 +    protected Content getProfile(String profileName) {
   10.28          Content profileLinkContent;
   10.29          Content profileLabel;
   10.30 -        String profileName = (Profile.lookup(profile)).name;
   10.31          profileLabel = new StringContent(profileName);
   10.32          profileLinkContent = getHyperLink(DocPaths.profileFrame(profileName), profileLabel, "",
   10.33                      "packageListFrame");

    11.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/ProfileWriterImpl.java	Thu Sep 12 11:09:20 2013 -0700
    11.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/ProfileWriterImpl.java	Tue Sep 17 08:21:11 2013 -0700
    11.3 @@ -138,6 +138,7 @@
    11.4                      "classFrame", new StringContent(pkg.name()), profile.name);
    11.5          Content heading = HtmlTree.HEADING(HtmlTag.H3, pkgName);
    11.6          HtmlTree li = HtmlTree.LI(HtmlStyle.blockList, heading);
    11.7 +        addPackageDeprecationInfo(li, pkg);
    11.8          return li;
    11.9      }
   11.10  
   11.11 @@ -175,6 +176,30 @@
   11.12      }
   11.13  
   11.14      /**
   11.15 +     * Add the profile package deprecation information to the documentation tree.
   11.16 +     *
   11.17 +     * @param li the content tree to which the deprecation information will be added
   11.18 +     * @param pkg the PackageDoc that is added
   11.19 +     */
   11.20 +    public void addPackageDeprecationInfo(Content li, PackageDoc pkg) {
   11.21 +        Tag[] deprs;
   11.22 +        if (Util.isDeprecated(pkg)) {
   11.23 +            deprs = pkg.tags("deprecated");
   11.24 +            HtmlTree deprDiv = new HtmlTree(HtmlTag.DIV);
   11.25 +            deprDiv.addStyle(HtmlStyle.deprecatedContent);
   11.26 +            Content deprPhrase = HtmlTree.SPAN(HtmlStyle.strong, deprecatedPhrase);
   11.27 +            deprDiv.addContent(deprPhrase);
   11.28 +            if (deprs.length > 0) {
   11.29 +                Tag[] commentTags = deprs[0].inlineTags();
   11.30 +                if (commentTags.length > 0) {
   11.31 +                    addInlineDeprecatedComment(pkg, deprs[0], deprDiv);
   11.32 +                }
   11.33 +            }
   11.34 +            li.addContent(deprDiv);
   11.35 +        }
   11.36 +    }
   11.37 +
   11.38 +    /**
   11.39       * Get "PREV PROFILE" link in the navigation bar.
   11.40       *
   11.41       * @return a content tree for the previous link

    12.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java	Thu Sep 12 11:09:20 2013 -0700
    12.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java	Tue Sep 17 08:21:11 2013 -0700
    12.3 @@ -191,10 +191,7 @@
    12.4          Content htmlDocType = DocType.FRAMESET;
    12.5          Content htmlComment = new Comment(configuration.getText("doclet.New_Page"));
    12.6          Content head = new HtmlTree(HtmlTag.HEAD);
    12.7 -        if (! noTimeStamp) {
    12.8 -            Content headComment = new Comment(getGeneratedByString());
    12.9 -            head.addContent(headComment);
   12.10 -        }
   12.11 +        head.addContent(getGeneratedBy(!noTimeStamp));
   12.12          if (configuration.charset.length() > 0) {
   12.13              Content meta = HtmlTree.META("Content-Type", CONTENT_TYPE,
   12.14                      configuration.charset);
   12.15 @@ -210,9 +207,13 @@
   12.16          write(htmlDocument);
   12.17      }
   12.18  
   12.19 -    protected String getGeneratedByString() {
   12.20 -        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
   12.21 -        Date today = calendar.getTime();
   12.22 -        return "Generated by javadoc ("+ ConfigurationImpl.BUILD_DATE + ") on " + today;
   12.23 +    protected Comment getGeneratedBy(boolean timestamp) {
   12.24 +        String text = "Generated by javadoc"; // marker string, deliberately not localized
   12.25 +        if (timestamp) {
   12.26 +            Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
   12.27 +            Date today = calendar.getTime();
   12.28 +            text += " ("+ ConfigurationImpl.BUILD_DATE + ") on " + today;
   12.29 +        }
   12.30 +        return new Comment(text);
   12.31      }
   12.32  }

    13.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlStyle.java	Thu Sep 12 11:09:20 2013 -0700
    13.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlStyle.java	Tue Sep 17 08:21:11 2013 -0700
    13.3 @@ -68,6 +68,7 @@
    13.4      packageSummary,
    13.5      rowColor,
    13.6      serializedFormContainer,
    13.7 +    skipNav,
    13.8      sourceContainer,
    13.9      sourceLineNo,
   13.10      strong,

    14.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java	Thu Sep 12 11:09:20 2013 -0700
    14.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java	Tue Sep 17 08:21:11 2013 -0700
    14.3 @@ -203,27 +203,27 @@
    14.4          useLabel = getResource("doclet.navClassUse");
    14.5          prevLabel = getResource("doclet.Prev");
    14.6          nextLabel = getResource("doclet.Next");
    14.7 -        prevclassLabel = getResource("doclet.Prev_Class");
    14.8 -        nextclassLabel = getResource("doclet.Next_Class");
    14.9 +        prevclassLabel = getNonBreakResource("doclet.Prev_Class");
   14.10 +        nextclassLabel = getNonBreakResource("doclet.Next_Class");
   14.11          summaryLabel = getResource("doclet.Summary");
   14.12          detailLabel = getResource("doclet.Detail");
   14.13          framesLabel = getResource("doclet.Frames");
   14.14 -        noframesLabel = getResource("doclet.No_Frames");
   14.15 +        noframesLabel = getNonBreakResource("doclet.No_Frames");
   14.16          treeLabel = getResource("doclet.Tree");
   14.17          classLabel = getResource("doclet.Class");
   14.18          deprecatedLabel = getResource("doclet.navDeprecated");
   14.19          deprecatedPhrase = getResource("doclet.Deprecated");
   14.20 -        allclassesLabel = getResource("doclet.All_Classes");
   14.21 -        allpackagesLabel = getResource("doclet.All_Packages");
   14.22 -        allprofilesLabel = getResource("doclet.All_Profiles");
   14.23 +        allclassesLabel = getNonBreakResource("doclet.All_Classes");
   14.24 +        allpackagesLabel = getNonBreakResource("doclet.All_Packages");
   14.25 +        allprofilesLabel = getNonBreakResource("doclet.All_Profiles");
   14.26          indexLabel = getResource("doclet.Index");
   14.27          helpLabel = getResource("doclet.Help");
   14.28          seeLabel = getResource("doclet.See");
   14.29          descriptionLabel = getResource("doclet.Description");
   14.30 -        prevpackageLabel = getResource("doclet.Prev_Package");
   14.31 -        nextpackageLabel = getResource("doclet.Next_Package");
   14.32 -        prevprofileLabel = getResource("doclet.Prev_Profile");
   14.33 -        nextprofileLabel = getResource("doclet.Next_Profile");
   14.34 +        prevpackageLabel = getNonBreakResource("doclet.Prev_Package");
   14.35 +        nextpackageLabel = getNonBreakResource("doclet.Next_Package");
   14.36 +        prevprofileLabel = getNonBreakResource("doclet.Prev_Profile");
   14.37 +        nextprofileLabel = getNonBreakResource("doclet.Next_Profile");
   14.38          packagesLabel = getResource("doclet.Packages");
   14.39          profilesLabel = getResource("doclet.Profiles");
   14.40          methodDetailsLabel = getResource("doclet.Method_Detail");
   14.41 @@ -257,6 +257,27 @@
   14.42      }
   14.43  
   14.44      /**
   14.45 +     * Get the configuration string as a content, replacing spaces
   14.46 +     * with non-breaking spaces.
   14.47 +     *
   14.48 +     * @param key the key to look for in the configuration file
   14.49 +     * @return a content tree for the text
   14.50 +     */
   14.51 +    public Content getNonBreakResource(String key) {
   14.52 +        String text = configuration.getText(key);
   14.53 +        Content c = configuration.newContent();
   14.54 +        int start = 0;
   14.55 +        int p;
   14.56 +        while ((p = text.indexOf(" ", start)) != -1) {
   14.57 +            c.addContent(text.substring(start, p));
   14.58 +            c.addContent(RawHtml.nbsp);
   14.59 +            start = p + 1;
   14.60 +        }
   14.61 +        c.addContent(text.substring(start));
   14.62 +        return c;
   14.63 +    }
   14.64 +
   14.65 +    /**
   14.66       * Get the configuration string as a content.
   14.67       *
   14.68       * @param key the key to look for in the configuration file

    15.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/Configuration.java	Thu Sep 12 11:09:20 2013 -0700
    15.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/Configuration.java	Tue Sep 17 08:21:11 2013 -0700
    15.3 @@ -383,35 +383,52 @@
    15.4          DocErrorReporter reporter);
    15.5  
    15.6      private void initProfiles() throws IOException {
    15.7 +        if (profilespath.isEmpty())
    15.8 +            return;
    15.9 +
   15.10          profiles = Profiles.read(new File(profilespath));
   15.11 -        // Generate profiles documentation only is profilespath is set and if
   15.12 -        // profiles is not null and profiles count is 1 or more.
   15.13 -        showProfiles = (!profilespath.isEmpty() && profiles != null &&
   15.14 -                profiles.getProfileCount() > 0);
   15.15 -    }
   15.16  
   15.17 -    private void initProfilePackages() throws IOException {
   15.18 +        // Group the packages to be documented by the lowest profile (if any)
   15.19 +        // in which each appears
   15.20 +        Map<Profile, List<PackageDoc>> interimResults =
   15.21 +                new EnumMap<Profile, List<PackageDoc>>(Profile.class);
   15.22 +        for (Profile p: Profile.values())
   15.23 +            interimResults.put(p, new ArrayList<PackageDoc>());
   15.24 +
   15.25 +        for (PackageDoc pkg: packages) {
   15.26 +            if (nodeprecated && Util.isDeprecated(pkg)) {
   15.27 +                continue;
   15.28 +            }
   15.29 +            // the getProfile method takes a type name, not a package name,
   15.30 +            // but isn't particularly fussy about the simple name -- so just use *
   15.31 +            int i = profiles.getProfile(pkg.name().replace(".", "/") + "/*");
   15.32 +            Profile p = Profile.lookup(i);
   15.33 +            if (p != null) {
   15.34 +                List<PackageDoc> pkgs = interimResults.get(p);
   15.35 +                pkgs.add(pkg);
   15.36 +            }
   15.37 +        }
   15.38 +
   15.39 +        // Build the profilePackages structure used by the doclet
   15.40          profilePackages = new HashMap<String,PackageDoc[]>();
   15.41 -        ArrayList<PackageDoc> results;
   15.42 -        Map<String,PackageDoc> packageIndex = new HashMap<String,PackageDoc>();
   15.43 -        for (int i = 0; i < packages.length; i++) {
   15.44 -            PackageDoc pkg = packages[i];
   15.45 -            packageIndex.put(pkg.name(), pkg);
   15.46 +        List<PackageDoc> prev = Collections.<PackageDoc>emptyList();
   15.47 +        int size;
   15.48 +        for (Map.Entry<Profile,List<PackageDoc>> e: interimResults.entrySet()) {
   15.49 +            Profile p = e.getKey();
   15.50 +            List<PackageDoc> pkgs =  e.getValue();
   15.51 +            pkgs.addAll(prev); // each profile contains all lower profiles
   15.52 +            Collections.sort(pkgs);
   15.53 +            size = pkgs.size();
   15.54 +            // For a profile, if there are no packages to be documented, do not add
   15.55 +            // it to profilePackages map.
   15.56 +            if (size > 0)
   15.57 +                profilePackages.put(p.name, pkgs.toArray(new PackageDoc[pkgs.size()]));
   15.58 +            prev = pkgs;
   15.59          }
   15.60 -        for (int i = 1; i < profiles.getProfileCount(); i++) {
   15.61 -            Set<String> profPkgs = profiles.getPackages(i);
   15.62 -            results = new ArrayList<PackageDoc>();
   15.63 -            for (String packageName : profPkgs) {
   15.64 -                packageName = packageName.replace("/", ".");
   15.65 -                PackageDoc profPkg = packageIndex.get(packageName);
   15.66 -                if (profPkg != null) {
   15.67 -                    results.add(profPkg);
   15.68 -                }
   15.69 -            }
   15.70 -            Collections.sort(results);
   15.71 -            PackageDoc[] profilePkgs = results.toArray(new PackageDoc[]{});
   15.72 -            profilePackages.put(Profile.lookup(i).name, profilePkgs);
   15.73 -        }
   15.74 +
   15.75 +        // Generate profiles documentation if any profile contains any
   15.76 +        // of the packages to be documented.
   15.77 +        showProfiles = !prev.isEmpty();
   15.78      }
   15.79  
   15.80      private void initPackageArray() {
   15.81 @@ -534,13 +551,10 @@
   15.82      public void setOptions() throws Fault {
   15.83          initPackageArray();
   15.84          setOptions(root.options());
   15.85 -        if (!profilespath.isEmpty()) {
   15.86 -            try {
   15.87 -                initProfiles();
   15.88 -                initProfilePackages();
   15.89 -            } catch (Exception e) {
   15.90 -                throw new DocletAbortException(e);
   15.91 -            }
   15.92 +        try {
   15.93 +            initProfiles();
   15.94 +        } catch (Exception e) {
   15.95 +            throw new DocletAbortException(e);
   15.96          }
   15.97          setSpecificDocletOptions(root.options());
   15.98      }
   15.99 @@ -713,6 +727,17 @@
  15.100      }
  15.101  
  15.102      /**
  15.103 +     * Check the validity of the given profile. Return false if there are no
  15.104 +     * valid packages to be documented for the profile.
  15.105 +     *
  15.106 +     * @param profileName the profile that needs to be validated.
  15.107 +     * @return true if the profile has valid packages to be documented.
  15.108 +     */
  15.109 +    public boolean shouldDocumentProfile(String profileName) {
  15.110 +        return profilePackages.containsKey(profileName);
  15.111 +    }
  15.112 +
  15.113 +    /**
  15.114       * Check the validity of the given Source or Output File encoding on this
  15.115       * platform.
  15.116       *

    16.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/stylesheet.css	Thu Sep 12 11:09:20 2013 -0700
    16.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/stylesheet.css	Tue Sep 17 08:21:11 2013 -0700
    16.3 @@ -180,6 +180,12 @@
    16.4      margin: auto 5px;
    16.5      border:1px solid #c9aa44;
    16.6  }
    16.7 +.skipNav {
    16.8 +    position:absolute;
    16.9 +    top:auto;
   16.10 +    left:-9999px;
   16.11 +    overflow:hidden;
   16.12 +    }
   16.13  /*
   16.14  Page header and footer styles
   16.15  */
   16.16 @@ -372,7 +378,6 @@
   16.17      overflow:hidden;
   16.18      padding:0px;
   16.19      margin:0px;
   16.20 -    white-space:pre;
   16.21  }
   16.22  caption a:link, caption a:hover, caption a:active, caption a:visited {
   16.23      color:#FFFFFF;
   16.24 @@ -381,35 +386,32 @@
   16.25      white-space:nowrap;
   16.26      padding-top:8px;
   16.27      padding-left:8px;
   16.28 -    display:block;
   16.29 +    display:inline-block;
   16.30      float:left;
   16.31      background-image:url(resources/titlebar.gif);
   16.32 -    height:18px;
   16.33  }
   16.34  .contentContainer ul.blockList li.blockList caption span.activeTableTab span {
   16.35      white-space:nowrap;
   16.36      padding-top:8px;
   16.37      padding-left:8px;
   16.38 -    display:block;
   16.39 +    display:inline-block;
   16.40      float:left;
   16.41      background-image:url(resources/activetitlebar.gif);
   16.42 -    height:18px;
   16.43  }
   16.44  .contentContainer ul.blockList li.blockList caption span.tableTab span {
   16.45      white-space:nowrap;
   16.46      padding-top:8px;
   16.47      padding-left:8px;
   16.48 -    display:block;
   16.49 +    display:inline-block;
   16.50      float:left;
   16.51      background-image:url(resources/titlebar.gif);
   16.52 -    height:18px;
   16.53  }
   16.54  .contentContainer ul.blockList li.blockList caption span.tableTab, .contentContainer ul.blockList li.blockList caption span.activeTableTab {
   16.55      padding-top:0px;
   16.56      padding-left:0px;
   16.57      background-image:none;
   16.58      float:none;
   16.59 -    display:inline;
   16.60 +    display:inline-block;
   16.61  }
   16.62  .overviewSummary .tabEnd, .packageSummary .tabEnd, .contentContainer ul.blockList li.blockList .tabEnd, .summary .tabEnd, .classUseContainer .tabEnd, .constantValuesContainer .tabEnd {
   16.63      width:10px;

    17.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/LegacyTaglet.java	Thu Sep 12 11:09:20 2013 -0700
    17.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/LegacyTaglet.java	Tue Sep 17 08:21:11 2013 -0700
    17.3 @@ -130,7 +130,13 @@
    17.4      public Content getTagletOutput(Doc holder, TagletWriter writer)
    17.5              throws IllegalArgumentException {
    17.6          Content output = writer.getOutputInstance();
    17.7 -        output.addContent(new RawHtml(legacyTaglet.toString(holder.tags(getName()))));
    17.8 +        Tag[] tags = holder.tags(getName());
    17.9 +        if (tags.length > 0) {
   17.10 +            String tagString = legacyTaglet.toString(tags);
   17.11 +            if (tagString != null) {
   17.12 +                output.addContent(new RawHtml(tagString));
   17.13 +            }
   17.14 +        }
   17.15          return output;
   17.16      }
   17.17  }

    18.1 --- a/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/PathDocFileFactory.java	Thu Sep 12 11:09:20 2013 -0700
    18.2 +++ b/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/PathDocFileFactory.java	Tue Sep 17 08:21:11 2013 -0700
    18.3 @@ -34,6 +34,7 @@
    18.4  import java.io.OutputStreamWriter;
    18.5  import java.io.UnsupportedEncodingException;
    18.6  import java.io.Writer;
    18.7 +import java.nio.file.DirectoryStream;
    18.8  import java.nio.file.Files;
    18.9  import java.nio.file.Path;
   18.10  import java.util.ArrayList;
   18.11 @@ -221,8 +222,10 @@
   18.12          /** If the file is a directory, list its contents. */
   18.13          public Iterable<DocFile> list() throws IOException {
   18.14              List<DocFile> files = new ArrayList<DocFile>();
   18.15 -            for (Path f: Files.newDirectoryStream(file)) {
   18.16 -                files.add(new StandardDocFile(f));
   18.17 +            try (DirectoryStream<Path> ds = Files.newDirectoryStream(file)) {
   18.18 +                for (Path f: ds) {
   18.19 +                    files.add(new StandardDocFile(f));
   18.20 +                }
   18.21              }
   18.22              return files;
   18.23          }

    19.1 --- a/src/share/classes/com/sun/tools/javac/Main.java	Thu Sep 12 11:09:20 2013 -0700
    19.2 +++ b/src/share/classes/com/sun/tools/javac/Main.java	Tue Sep 17 08:21:11 2013 -0700
    19.3 @@ -30,14 +30,6 @@
    19.4  /**
    19.5   * The programmatic interface for the Java Programming Language
    19.6   * compiler, javac.
    19.7 - *
    19.8 - * <p>Except for the two methods
    19.9 - * {@link #compile(java.lang.String[])}
   19.10 - * {@link #compile(java.lang.String[],java.io.PrintWriter)},
   19.11 - * nothing described in this source file is part of any supported
   19.12 - * API.  If you write code that depends on this, you do so at your own
   19.13 - * risk.  This code and its internal interfaces are subject to change
   19.14 - * or deletion without notice.
   19.15   */
   19.16  @jdk.Supported
   19.17  public class Main {

    20.1 --- a/src/share/classes/com/sun/tools/javac/code/Annotations.java	Thu Sep 12 11:09:20 2013 -0700
    20.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.3 @@ -1,451 +0,0 @@
    20.4 -/*
    20.5 - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
    20.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    20.7 - *
    20.8 - * This code is free software; you can redistribute it and/or modify it
    20.9 - * under the terms of the GNU General Public License version 2 only, as
   20.10 - * published by the Free Software Foundation.  Oracle designates this
   20.11 - * particular file as subject to the "Classpath" exception as provided
   20.12 - * by Oracle in the LICENSE file that accompanied this code.
   20.13 - *
   20.14 - * This code is distributed in the hope that it will be useful, but WITHOUT
   20.15 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   20.16 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   20.17 - * version 2 for more details (a copy is included in the LICENSE file that
   20.18 - * accompanied this code).
   20.19 - *
   20.20 - * You should have received a copy of the GNU General Public License version
   20.21 - * 2 along with this work; if not, write to the Free Software Foundation,
   20.22 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20.23 - *
   20.24 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   20.25 - * or visit www.oracle.com if you need additional information or have any
   20.26 - * questions.
   20.27 - */
   20.28 -
   20.29 -package com.sun.tools.javac.code;
   20.30 -
   20.31 -import java.util.Map;
   20.32 -
   20.33 -import javax.tools.JavaFileObject;
   20.34 -
   20.35 -import com.sun.tools.javac.comp.Annotate;
   20.36 -import com.sun.tools.javac.comp.AttrContext;
   20.37 -import com.sun.tools.javac.comp.Env;
   20.38 -import com.sun.tools.javac.util.*;
   20.39 -import com.sun.tools.javac.util.Assert;
   20.40 -import com.sun.tools.javac.util.List;
   20.41 -import com.sun.tools.javac.util.Log;
   20.42 -import com.sun.tools.javac.util.Pair;
   20.43 -import static com.sun.tools.javac.code.Kinds.PCK;
   20.44 -
   20.45 -/**
   20.46 - * Container for all annotations (attributes in javac) on a Symbol.
   20.47 - *
   20.48 - * This class is explicitly mutable. Its contents will change when attributes
   20.49 - * are annotated onto the Symbol. However this class depends on the facts that
   20.50 - * List (in javac) is immutable.
   20.51 - *
   20.52 - * An instance of this class can be in one of three states:
   20.53 - *
   20.54 - * NOT_STARTED indicates that the Symbol this instance belongs to has not been
   20.55 - * annotated (yet). Specifically if the declaration is not annotated this
   20.56 - * instance will never move past NOT_STARTED. You can never go back to
   20.57 - * NOT_STARTED.
   20.58 - *
   20.59 - * IN_PROGRESS annotations have been found on the declaration. Will be processed
   20.60 - * later. You can reset to IN_PROGRESS. While IN_PROGRESS you can set the list
   20.61 - * of attributes (and this moves out of the IN_PROGRESS state).
   20.62 - *
   20.63 - * "unnamed" this Annotations contains some attributes, possibly the final set.
   20.64 - * While in this state you can only prepend or append to the attributes not set
   20.65 - * it directly. You can also move back to the IN_PROGRESS state using reset().
   20.66 - *
   20.67 - * <p><b>This is NOT part of any supported API. If you write code that depends
   20.68 - * on this, you do so at your own risk. This code and its internal interfaces
   20.69 - * are subject to change or deletion without notice.</b>
   20.70 - */
   20.71 -public class Annotations {
   20.72 -
   20.73 -    private static final List<Attribute.Compound> DECL_NOT_STARTED = List.of(null);
   20.74 -    private static final List<Attribute.Compound> DECL_IN_PROGRESS = List.of(null);
   20.75 -
   20.76 -    /*
   20.77 -     * This field should never be null
   20.78 -     */
   20.79 -    private List<Attribute.Compound> attributes = DECL_NOT_STARTED;
   20.80 -
   20.81 -    /*
   20.82 -     * Type attributes for this symbol.
   20.83 -     * This field should never be null.
   20.84 -     */
   20.85 -    private List<Attribute.TypeCompound> type_attributes = List.<Attribute.TypeCompound>nil();
   20.86 -
   20.87 -    /*
   20.88 -     * Type attributes of initializers in this class.
   20.89 -     * Unused if the current symbol is not a ClassSymbol.
   20.90 -     */
   20.91 -    private List<Attribute.TypeCompound> init_type_attributes = List.<Attribute.TypeCompound>nil();
   20.92 -
   20.93 -    /*
   20.94 -     * Type attributes of class initializers in this class.
   20.95 -     * Unused if the current symbol is not a ClassSymbol.
   20.96 -     */
   20.97 -    private List<Attribute.TypeCompound> clinit_type_attributes = List.<Attribute.TypeCompound>nil();
   20.98 -
   20.99 -    /*
  20.100 -     * The Symbol this Annotations instance belongs to
  20.101 -     */
  20.102 -    private final Symbol sym;
  20.103 -
  20.104 -    public Annotations(Symbol sym) {
  20.105 -        this.sym = sym;
  20.106 -    }
  20.107 -
  20.108 -    public List<Attribute.Compound> getDeclarationAttributes() {
  20.109 -        return filterDeclSentinels(attributes);
  20.110 -    }
  20.111 -
  20.112 -    public List<Attribute.TypeCompound> getTypeAttributes() {
  20.113 -        return type_attributes;
  20.114 -    }
  20.115 -
  20.116 -    public List<Attribute.TypeCompound> getInitTypeAttributes() {
  20.117 -        return init_type_attributes;
  20.118 -    }
  20.119 -
  20.120 -    public List<Attribute.TypeCompound> getClassInitTypeAttributes() {
  20.121 -        return clinit_type_attributes;
  20.122 -    }
  20.123 -
  20.124 -    public void setDeclarationAttributes(List<Attribute.Compound> a) {
  20.125 -        Assert.check(pendingCompletion() || !isStarted());
  20.126 -        if (a == null) {
  20.127 -            throw new NullPointerException();
  20.128 -        }
  20.129 -        attributes = a;
  20.130 -    }
  20.131 -
  20.132 -    public void setTypeAttributes(List<Attribute.TypeCompound> a) {
  20.133 -        if (a == null) {
  20.134 -            throw new NullPointerException();
  20.135 -        }
  20.136 -        type_attributes = a;
  20.137 -    }
  20.138 -
  20.139 -    public void setInitTypeAttributes(List<Attribute.TypeCompound> a) {
  20.140 -        if (a == null) {
  20.141 -            throw new NullPointerException();
  20.142 -        }
  20.143 -        init_type_attributes = a;
  20.144 -    }
  20.145 -
  20.146 -    public void setClassInitTypeAttributes(List<Attribute.TypeCompound> a) {
  20.147 -        if (a == null) {
  20.148 -            throw new NullPointerException();
  20.149 -        }
  20.150 -        clinit_type_attributes = a;
  20.151 -    }
  20.152 -
  20.153 -    public void setAttributes(Annotations other) {
  20.154 -        if (other == null) {
  20.155 -            throw new NullPointerException();
  20.156 -        }
  20.157 -        setDeclarationAttributes(other.getDeclarationAttributes());
  20.158 -        setTypeAttributes(other.getTypeAttributes());
  20.159 -        setInitTypeAttributes(other.getInitTypeAttributes());
  20.160 -        setClassInitTypeAttributes(other.getClassInitTypeAttributes());
  20.161 -    }
  20.162 -
  20.163 -    public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.Compound> ctx) {
  20.164 -        Assert.check(pendingCompletion() || (!isStarted() && sym.kind == PCK));
  20.165 -        this.setDeclarationAttributes(getAttributesForCompletion(ctx));
  20.166 -    }
  20.167 -
  20.168 -    public void appendTypeAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.TypeCompound> ctx) {
  20.169 -        this.appendUniqueTypes(getAttributesForCompletion(ctx));
  20.170 -    }
  20.171 -
  20.172 -    private <T extends Attribute.Compound> List<T> getAttributesForCompletion(
  20.173 -            final Annotate.AnnotateRepeatedContext<T> ctx) {
  20.174 -
  20.175 -        Map<Symbol.TypeSymbol, ListBuffer<T>> annotated = ctx.annotated;
  20.176 -        boolean atLeastOneRepeated = false;
  20.177 -        List<T> buf = List.<T>nil();
  20.178 -        for (ListBuffer<T> lb : annotated.values()) {
  20.179 -            if (lb.size() == 1) {
  20.180 -                buf = buf.prepend(lb.first());
  20.181 -            } else { // repeated
  20.182 -                // This will break when other subtypes of Attributs.Compound
  20.183 -                // are introduced, because PlaceHolder is a subtype of TypeCompound.
  20.184 -                T res;
  20.185 -                @SuppressWarnings("unchecked")
  20.186 -                T ph = (T) new Placeholder<T>(ctx, lb.toList(), sym);
  20.187 -                res = ph;
  20.188 -                buf = buf.prepend(res);
  20.189 -                atLeastOneRepeated = true;
  20.190 -            }
  20.191 -        }
  20.192 -
  20.193 -        if (atLeastOneRepeated) {
  20.194 -            // The Symbol s is now annotated with a combination of
  20.195 -            // finished non-repeating annotations and placeholders for
  20.196 -            // repeating annotations.
  20.197 -            //
  20.198 -            // We need to do this in two passes because when creating
  20.199 -            // a container for a repeating annotation we must
  20.200 -            // guarantee that the @Repeatable on the
  20.201 -            // contained annotation is fully annotated
  20.202 -            //
  20.203 -            // The way we force this order is to do all repeating
  20.204 -            // annotations in a pass after all non-repeating are
  20.205 -            // finished. This will work because @Repeatable
  20.206 -            // is non-repeating and therefore will be annotated in the
  20.207 -            // fist pass.
  20.208 -
  20.209 -            // Queue a pass that will replace Attribute.Placeholders
  20.210 -            // with Attribute.Compound (made from synthesized containers).
  20.211 -            ctx.annotateRepeated(new Annotate.Annotator() {
  20.212 -                @Override
  20.213 -                public String toString() {
  20.214 -                    return "repeated annotation pass of: " + sym + " in: " + sym.owner;
  20.215 -                }
  20.216 -
  20.217 -                @Override
  20.218 -                public void enterAnnotation() {
  20.219 -                    complete(ctx);
  20.220 -                }
  20.221 -            });
  20.222 -        }
  20.223 -        // Add non-repeating attributes
  20.224 -        return buf.reverse();
  20.225 -    }
  20.226 -
  20.227 -    public Annotations reset() {
  20.228 -        attributes = DECL_IN_PROGRESS;
  20.229 -        return this;
  20.230 -    }
  20.231 -
  20.232 -    public boolean isEmpty() {
  20.233 -        return !isStarted()
  20.234 -                || pendingCompletion()
  20.235 -                || attributes.isEmpty();
  20.236 -    }
  20.237 -
  20.238 -    public boolean isTypesEmpty() {
  20.239 -        return type_attributes.isEmpty();
  20.240 -    }
  20.241 -
  20.242 -    public boolean pendingCompletion() {
  20.243 -        return attributes == DECL_IN_PROGRESS;
  20.244 -    }
  20.245 -
  20.246 -    public Annotations append(List<Attribute.Compound> l) {
  20.247 -        attributes = filterDeclSentinels(attributes);
  20.248 -
  20.249 -        if (l.isEmpty()) {
  20.250 -            ; // no-op
  20.251 -        } else if (attributes.isEmpty()) {
  20.252 -            attributes = l;
  20.253 -        } else {
  20.254 -            attributes = attributes.appendList(l);
  20.255 -        }
  20.256 -        return this;
  20.257 -    }
  20.258 -
  20.259 -    public Annotations appendUniqueTypes(List<Attribute.TypeCompound> l) {
  20.260 -        if (l.isEmpty()) {
  20.261 -            ; // no-op
  20.262 -        } else if (type_attributes.isEmpty()) {
  20.263 -            type_attributes = l;
  20.264 -        } else {
  20.265 -            // TODO: in case we expect a large number of annotations, this
  20.266 -            // might be inefficient.
  20.267 -            for (Attribute.TypeCompound tc : l) {
  20.268 -                if (!type_attributes.contains(tc))
  20.269 -                    type_attributes = type_attributes.append(tc);
  20.270 -            }
  20.271 -        }
  20.272 -        return this;
  20.273 -    }
  20.274 -
  20.275 -    public Annotations appendInitTypeAttributes(List<Attribute.TypeCompound> l) {
  20.276 -        if (l.isEmpty()) {
  20.277 -            ; // no-op
  20.278 -        } else if (init_type_attributes.isEmpty()) {
  20.279 -            init_type_attributes = l;
  20.280 -        } else {
  20.281 -            init_type_attributes = init_type_attributes.appendList(l);
  20.282 -        }
  20.283 -        return this;
  20.284 -    }
  20.285 -
  20.286 -    public Annotations appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {
  20.287 -        if (l.isEmpty()) {
  20.288 -            ; // no-op
  20.289 -        } else if (clinit_type_attributes.isEmpty()) {
  20.290 -            clinit_type_attributes = l;
  20.291 -        } else {
  20.292 -            clinit_type_attributes = clinit_type_attributes.appendList(l);
  20.293 -        }
  20.294 -        return this;
  20.295 -    }
  20.296 -
  20.297 -    public Annotations prepend(List<Attribute.Compound> l) {
  20.298 -        attributes = filterDeclSentinels(attributes);
  20.299 -
  20.300 -        if (l.isEmpty()) {
  20.301 -            ; // no-op
  20.302 -        } else if (attributes.isEmpty()) {
  20.303 -            attributes = l;
  20.304 -        } else {
  20.305 -            attributes = attributes.prependList(l);
  20.306 -        }
  20.307 -        return this;
  20.308 -    }
  20.309 -
  20.310 -    private List<Attribute.Compound> filterDeclSentinels(List<Attribute.Compound> a) {
  20.311 -        return (a == DECL_IN_PROGRESS || a == DECL_NOT_STARTED)
  20.312 -                ? List.<Attribute.Compound>nil()
  20.313 -                : a;
  20.314 -    }
  20.315 -
  20.316 -    private boolean isStarted() {
  20.317 -        return attributes != DECL_NOT_STARTED;
  20.318 -    }
  20.319 -
  20.320 -    private List<Attribute.Compound> getPlaceholders() {
  20.321 -        List<Attribute.Compound> res = List.<Attribute.Compound>nil();
  20.322 -        for (Attribute.Compound a : filterDeclSentinels(attributes)) {
  20.323 -            if (a instanceof Placeholder) {
  20.324 -                res = res.prepend(a);
  20.325 -            }
  20.326 -        }
  20.327 -        return res.reverse();
  20.328 -    }
  20.329 -
  20.330 -    private List<Attribute.TypeCompound> getTypePlaceholders() {
  20.331 -        List<Attribute.TypeCompound> res = List.<Attribute.TypeCompound>nil();
  20.332 -        for (Attribute.TypeCompound a : type_attributes) {
  20.333 -            if (a instanceof Placeholder) {
  20.334 -                res = res.prepend(a);
  20.335 -            }
  20.336 -        }
  20.337 -        return res.reverse();
  20.338 -    }
  20.339 -
  20.340 -    /*
  20.341 -     * Replace Placeholders for repeating annotations with their containers
  20.342 -     */
  20.343 -    private <T extends Attribute.Compound> void complete(Annotate.AnnotateRepeatedContext<T> ctx) {
  20.344 -        Log log = ctx.log;
  20.345 -        Env<AttrContext> env = ctx.env;
  20.346 -        JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);
  20.347 -        try {
  20.348 -            // TODO: can we reduce duplication in the following branches?
  20.349 -            if (ctx.isTypeCompound) {
  20.350 -                Assert.check(!isTypesEmpty());
  20.351 -
  20.352 -                if (isTypesEmpty()) {
  20.353 -                    return;
  20.354 -                }
  20.355 -
  20.356 -                List<Attribute.TypeCompound> result = List.nil();
  20.357 -                for (Attribute.TypeCompound a : getTypeAttributes()) {
  20.358 -                    if (a instanceof Placeholder) {
  20.359 -                        @SuppressWarnings("unchecked")
  20.360 -                        Placeholder<Attribute.TypeCompound> ph = (Placeholder<Attribute.TypeCompound>) a;
  20.361 -                        Attribute.TypeCompound replacement = replaceOne(ph, ph.getRepeatedContext());
  20.362 -
  20.363 -                        if (null != replacement) {
  20.364 -                            result = result.prepend(replacement);
  20.365 -                        }
  20.366 -                    } else {
  20.367 -                        result = result.prepend(a);
  20.368 -                    }
  20.369 -                }
  20.370 -
  20.371 -                type_attributes = result.reverse();
  20.372 -
  20.373 -                Assert.check(Annotations.this.getTypePlaceholders().isEmpty());
  20.374 -            } else {
  20.375 -                Assert.check(!pendingCompletion());
  20.376 -
  20.377 -                if (isEmpty()) {
  20.378 -                    return;
  20.379 -                }
  20.380 -
  20.381 -                List<Attribute.Compound> result = List.nil();
  20.382 -                for (Attribute.Compound a : getDeclarationAttributes()) {
  20.383 -                    if (a instanceof Placeholder) {
  20.384 -                        @SuppressWarnings("unchecked")
  20.385 -                        Attribute.Compound replacement = replaceOne((Placeholder<T>) a, ctx);
  20.386 -
  20.387 -                        if (null != replacement) {
  20.388 -                            result = result.prepend(replacement);
  20.389 -                        }
  20.390 -                    } else {
  20.391 -                        result = result.prepend(a);
  20.392 -                    }
  20.393 -                }
  20.394 -
  20.395 -                attributes = result.reverse();
  20.396 -
  20.397 -                Assert.check(Annotations.this.getPlaceholders().isEmpty());
  20.398 -            }
  20.399 -        } finally {
  20.400 -            log.useSource(oldSource);
  20.401 -        }
  20.402 -    }
  20.403 -
  20.404 -    private <T extends Attribute.Compound> T replaceOne(Placeholder<T> placeholder, Annotate.AnnotateRepeatedContext<T> ctx) {
  20.405 -        Log log = ctx.log;
  20.406 -
  20.407 -        // Process repeated annotations
  20.408 -        T validRepeated = ctx.processRepeatedAnnotations(placeholder.getPlaceholderFor(), sym);
  20.409 -
  20.410 -        if (validRepeated != null) {
  20.411 -            // Check that the container isn't manually
  20.412 -            // present along with repeated instances of
  20.413 -            // its contained annotation.
  20.414 -            ListBuffer<T> manualContainer = ctx.annotated.get(validRepeated.type.tsym);
  20.415 -            if (manualContainer != null) {
  20.416 -                log.error(ctx.pos.get(manualContainer.first()), "invalid.repeatable.annotation.repeated.and.container.present",
  20.417 -                        manualContainer.first().type.tsym);
  20.418 -            }
  20.419 -        }
  20.420 -
  20.421 -        // A null return will delete the Placeholder
  20.422 -        return validRepeated;
  20.423 -    }
  20.424 -
  20.425 -    private static class Placeholder<T extends Attribute.Compound> extends Attribute.TypeCompound {
  20.426 -
  20.427 -        private final Annotate.AnnotateRepeatedContext<T> ctx;
  20.428 -        private final List<T> placeholderFor;
  20.429 -        private final Symbol on;
  20.430 -
  20.431 -        public Placeholder(Annotate.AnnotateRepeatedContext<T> ctx, List<T> placeholderFor, Symbol on) {
  20.432 -            super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),
  20.433 -                    ctx.isTypeCompound ?
  20.434 -                            ((Attribute.TypeCompound)placeholderFor.head).position :
  20.435 -                                null);
  20.436 -            this.ctx = ctx;
  20.437 -            this.placeholderFor = placeholderFor;
  20.438 -            this.on = on;
  20.439 -        }
  20.440 -
  20.441 -        @Override
  20.442 -        public String toString() {
  20.443 -            return "<placeholder: " + placeholderFor + " on: " + on + ">";
  20.444 -        }
  20.445 -
  20.446 -        public List<T> getPlaceholderFor() {
  20.447 -            return placeholderFor;
  20.448 -        }
  20.449 -
  20.450 -        public Annotate.AnnotateRepeatedContext<T> getRepeatedContext() {
  20.451 -            return ctx;
  20.452 -        }
  20.453 -    }
  20.454 -}

    21.1 --- a/src/share/classes/com/sun/tools/javac/code/DeferredLintHandler.java	Thu Sep 12 11:09:20 2013 -0700
    21.2 +++ b/src/share/classes/com/sun/tools/javac/code/DeferredLintHandler.java	Tue Sep 17 08:21:11 2013 -0700
    21.3 @@ -1,5 +1,5 @@
    21.4  /*
    21.5 - * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
    21.6 + * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
    21.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    21.8   *
    21.9   * This code is free software; you can redistribute it and/or modify it
   21.10 @@ -28,6 +28,8 @@
   21.11  import java.util.HashMap;
   21.12  import java.util.Map;
   21.13  
   21.14 +import com.sun.tools.javac.tree.EndPosTable;
   21.15 +import com.sun.tools.javac.tree.JCTree;
   21.16  import com.sun.tools.javac.util.Assert;
   21.17  import com.sun.tools.javac.util.Context;
   21.18  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
   21.19 @@ -53,10 +55,13 @@
   21.20  
   21.21      protected DeferredLintHandler(Context context) {
   21.22          context.put(deferredLintHandlerKey, this);
   21.23 +        this.currentPos = IMMEDIATE_POSITION;
   21.24      }
   21.25  
   21.26 -    private DeferredLintHandler() {}
   21.27 -
   21.28 +    /**An interface for deferred lint reporting - loggers passed to
   21.29 +     * {@link #report(LintLogger) } will be called when
   21.30 +     * {@link #flush(DiagnosticPosition) } is invoked.
   21.31 +     */
   21.32      public interface LintLogger {
   21.33          void report();
   21.34      }
   21.35 @@ -64,12 +69,26 @@
   21.36      private DiagnosticPosition currentPos;
   21.37      private Map<DiagnosticPosition, ListBuffer<LintLogger>> loggersQueue = new HashMap<DiagnosticPosition, ListBuffer<LintLogger>>();
   21.38  
   21.39 +    /**Associate the given logger with the current position as set by {@link #setPos(DiagnosticPosition) }.
   21.40 +     * Will be invoked when {@link #flush(DiagnosticPosition) } will be invoked with the same position.
   21.41 +     * <br>
   21.42 +     * Will invoke the logger synchronously if {@link #immediate() } was called
   21.43 +     * instead of {@link #setPos(DiagnosticPosition) }.
   21.44 +     */
   21.45      public void report(LintLogger logger) {
   21.46 -        ListBuffer<LintLogger> loggers = loggersQueue.get(currentPos);
   21.47 -        Assert.checkNonNull(loggers);
   21.48 -        loggers.append(logger);
   21.49 +        if (currentPos == IMMEDIATE_POSITION) {
   21.50 +            logger.report();
   21.51 +        } else {
   21.52 +            ListBuffer<LintLogger> loggers = loggersQueue.get(currentPos);
   21.53 +            if (loggers == null) {
   21.54 +                loggersQueue.put(currentPos, loggers = ListBuffer.<LintLogger>lb());
   21.55 +            }
   21.56 +            loggers.append(logger);
   21.57 +        }
   21.58      }
   21.59  
   21.60 +    /**Invoke all {@link LintLogger}s that were associated with the provided {@code pos}.
   21.61 +     */
   21.62      public void flush(DiagnosticPosition pos) {
   21.63          ListBuffer<LintLogger> loggers = loggersQueue.get(pos);
   21.64          if (loggers != null) {
   21.65 @@ -80,16 +99,46 @@
   21.66          }
   21.67      }
   21.68  
   21.69 -    public DeferredLintHandler setPos(DiagnosticPosition currentPos) {
   21.70 +    /**Sets the current position to the provided {@code currentPos}. {@link LintLogger}s
   21.71 +     * passed to subsequent invocations of {@link #report(LintLogger) } will be associated
   21.72 +     * with the given position.
   21.73 +     */
   21.74 +    public DiagnosticPosition setPos(DiagnosticPosition currentPos) {
   21.75 +        DiagnosticPosition prevPosition = this.currentPos;
   21.76          this.currentPos = currentPos;
   21.77 -        loggersQueue.put(currentPos, ListBuffer.<LintLogger>lb());
   21.78 -        return this;
   21.79 +        return prevPosition;
   21.80      }
   21.81  
   21.82 -    public static final DeferredLintHandler immediateHandler = new DeferredLintHandler() {
   21.83 +    /**{@link LintLogger}s passed to subsequent invocations of
   21.84 +     * {@link #report(LintLogger) } will be invoked immediately.
   21.85 +     */
   21.86 +    public DiagnosticPosition immediate() {
   21.87 +        return setPos(IMMEDIATE_POSITION);
   21.88 +    }
   21.89 +
   21.90 +    private static final DiagnosticPosition IMMEDIATE_POSITION = new DiagnosticPosition() {
   21.91          @Override
   21.92 -        public void report(LintLogger logger) {
   21.93 -            logger.report();
   21.94 +        public JCTree getTree() {
   21.95 +            Assert.error();
   21.96 +            return null;
   21.97 +        }
   21.98 +
   21.99 +        @Override
  21.100 +        public int getStartPosition() {
  21.101 +            Assert.error();
  21.102 +            return -1;
  21.103 +        }
  21.104 +
  21.105 +        @Override
  21.106 +        public int getPreferredPosition() {
  21.107 +            Assert.error();
  21.108 +            return -1;
  21.109 +        }
  21.110 +
  21.111 +        @Override
  21.112 +        public int getEndPosition(EndPosTable endPosTable) {
  21.113 +            Assert.error();
  21.114 +            return -1;
  21.115          }
  21.116      };
  21.117  }

    22.1 --- a/src/share/classes/com/sun/tools/javac/code/Flags.java	Thu Sep 12 11:09:20 2013 -0700
    22.2 +++ b/src/share/classes/com/sun/tools/javac/code/Flags.java	Tue Sep 17 08:21:11 2013 -0700
    22.3 @@ -97,7 +97,6 @@
    22.4      public static final int MANDATED     = 1<<15;
    22.5  
    22.6      public static final int StandardFlags = 0x0fff;
    22.7 -    public static final int ModifierFlags = StandardFlags & ~INTERFACE;
    22.8  
    22.9      // Because the following access flags are overloaded with other
   22.10      // bit positions, we translate them when reading and writing class
   22.11 @@ -266,6 +265,11 @@
   22.12       */
   22.13      public static final long THROWS = 1L<<47;
   22.14  
   22.15 +    /**
   22.16 +     * Flag that marks potentially ambiguous overloads
   22.17 +     */
   22.18 +    public static final long POTENTIALLY_AMBIGUOUS = 1L<<48;
   22.19 +
   22.20      /** Modifier masks.
   22.21       */
   22.22      public static final int
   22.23 @@ -282,7 +286,9 @@
   22.24                                  SYNCHRONIZED | FINAL | STRICTFP;
   22.25      public static final long
   22.26          ExtendedStandardFlags       = (long)StandardFlags | DEFAULT,
   22.27 +        ModifierFlags               = ((long)StandardFlags & ~INTERFACE) | DEFAULT,
   22.28          InterfaceMethodMask         = ABSTRACT | STATIC | PUBLIC | STRICTFP | DEFAULT,
   22.29 +        AnnotationTypeElementMask   = FINAL | ABSTRACT | PUBLIC | STRICTFP,
   22.30          LocalVarFlags               = FINAL | PARAMETER;
   22.31  
   22.32  

    23.1 --- a/src/share/classes/com/sun/tools/javac/code/Lint.java	Thu Sep 12 11:09:20 2013 -0700
    23.2 +++ b/src/share/classes/com/sun/tools/javac/code/Lint.java	Tue Sep 17 08:21:11 2013 -0700
    23.3 @@ -33,9 +33,6 @@
    23.4  import com.sun.tools.javac.util.Options;
    23.5  import com.sun.tools.javac.util.Pair;
    23.6  
    23.7 -import static com.sun.tools.javac.code.Flags.*;
    23.8 -
    23.9 -
   23.10  /**
   23.11   * A class for handling -Xlint suboptions and @SuppresssWarnings.
   23.12   *
   23.13 @@ -81,7 +78,6 @@
   23.14          return l;
   23.15      }
   23.16  
   23.17 -
   23.18      private final AugmentVisitor augmentor;
   23.19  
   23.20      private final EnumSet<LintCategory> values;
   23.21 @@ -90,7 +86,6 @@
   23.22      private static final Map<String, LintCategory> map =
   23.23              new java.util.concurrent.ConcurrentHashMap<String, LintCategory>(20);
   23.24  
   23.25 -
   23.26      protected Lint(Context context) {
   23.27          // initialize values according to the lint options
   23.28          Options options = Options.instance(context);
   23.29 @@ -175,6 +170,11 @@
   23.30          OPTIONS("options"),
   23.31  
   23.32          /**
   23.33 +         * Warn about issues regarding method overloads.
   23.34 +         */
   23.35 +        OVERLOADS("overloads"),
   23.36 +
   23.37 +        /**
   23.38           * Warn about issues regarding method overrides.
   23.39           */
   23.40          OVERRIDES("overrides"),

    24.1 --- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Thu Sep 12 11:09:20 2013 -0700
    24.2 +++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Tue Sep 17 08:21:11 2013 -0700
    24.3 @@ -46,6 +46,7 @@
    24.4  import static com.sun.tools.javac.code.TypeTag.CLASS;
    24.5  import static com.sun.tools.javac.code.TypeTag.FORALL;
    24.6  import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
    24.7 +import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
    24.8  
    24.9  /** Root class for Java symbols. It contains subclasses
   24.10   *  for specific sorts of symbols, such as variables, methods and operators,
   24.11 @@ -98,9 +99,9 @@
   24.12      // <editor-fold defaultstate="collapsed" desc="annotations">
   24.13  
   24.14      /** The attributes of this symbol are contained in this
   24.15 -     * Annotations. The Annotations instance is NOT immutable.
   24.16 +     * SymbolMetadata. The SymbolMetadata instance is NOT immutable.
   24.17       */
   24.18 -    protected Annotations annotations;
   24.19 +    protected SymbolMetadata annotations;
   24.20  
   24.21      /** An accessor method for the attributes of this symbol.
   24.22       *  Attributes of class symbols should be accessed through the accessor
   24.23 @@ -217,19 +218,19 @@
   24.24      public void setTypeAttributes(List<Attribute.TypeCompound> a) {
   24.25          if (annotations != null || a.nonEmpty()) {
   24.26              if (annotations == null)
   24.27 -                annotations = new Annotations(this);
   24.28 +                annotations = new SymbolMetadata(this);
   24.29              annotations.setTypeAttributes(a);
   24.30          }
   24.31      }
   24.32  
   24.33 -    private Annotations initedAnnos() {
   24.34 +    private SymbolMetadata initedAnnos() {
   24.35          if (annotations == null)
   24.36 -            annotations = new Annotations(this);
   24.37 +            annotations = new SymbolMetadata(this);
   24.38          return annotations;
   24.39      }
   24.40  
   24.41      /** This method is intended for debugging only. */
   24.42 -    public Annotations getAnnotations() {
   24.43 +    public SymbolMetadata getAnnotations() {
   24.44          return annotations;
   24.45      }
   24.46  
   24.47 @@ -852,7 +853,7 @@
   24.48          private void mergeAttributes() {
   24.49              if (annotations == null &&
   24.50                  package_info.annotations != null) {
   24.51 -                annotations = new Annotations(this);
   24.52 +                annotations = new SymbolMetadata(this);
   24.53                  annotations.setAttributes(package_info.annotations);
   24.54              }
   24.55          }
   24.56 @@ -1167,11 +1168,11 @@
   24.57  
   24.58          public void setLazyConstValue(final Env<AttrContext> env,
   24.59                                        final Attr attr,
   24.60 -                                      final JCTree.JCExpression initializer)
   24.61 +                                      final JCVariableDecl variable)
   24.62          {
   24.63              setData(new Callable<Object>() {
   24.64                  public Object call() {
   24.65 -                    return attr.attribLazyConstantValue(env, initializer, type);
   24.66 +                    return attr.attribLazyConstantValue(env, variable, type);
   24.67                  }
   24.68              });
   24.69          }

    25.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.2 +++ b/src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java	Tue Sep 17 08:21:11 2013 -0700
    25.3 @@ -0,0 +1,451 @@
    25.4 +/*
    25.5 + * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
    25.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    25.7 + *
    25.8 + * This code is free software; you can redistribute it and/or modify it
    25.9 + * under the terms of the GNU General Public License version 2 only, as
   25.10 + * published by the Free Software Foundation.  Oracle designates this
   25.11 + * particular file as subject to the "Classpath" exception as provided
   25.12 + * by Oracle in the LICENSE file that accompanied this code.
   25.13 + *
   25.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   25.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   25.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   25.17 + * version 2 for more details (a copy is included in the LICENSE file that
   25.18 + * accompanied this code).
   25.19 + *
   25.20 + * You should have received a copy of the GNU General Public License version
   25.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   25.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   25.23 + *
   25.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   25.25 + * or visit www.oracle.com if you need additional information or have any
   25.26 + * questions.
   25.27 + */
   25.28 +
   25.29 +package com.sun.tools.javac.code;
   25.30 +
   25.31 +import java.util.Map;
   25.32 +
   25.33 +import javax.tools.JavaFileObject;
   25.34 +
   25.35 +import com.sun.tools.javac.comp.Annotate;
   25.36 +import com.sun.tools.javac.comp.AttrContext;
   25.37 +import com.sun.tools.javac.comp.Env;
   25.38 +import com.sun.tools.javac.util.*;
   25.39 +import com.sun.tools.javac.util.Assert;
   25.40 +import com.sun.tools.javac.util.List;
   25.41 +import com.sun.tools.javac.util.Log;
   25.42 +import com.sun.tools.javac.util.Pair;
   25.43 +import static com.sun.tools.javac.code.Kinds.PCK;
   25.44 +
   25.45 +/**
   25.46 + * Container for all annotations (attributes in javac) on a Symbol.
   25.47 + *
   25.48 + * This class is explicitly mutable. Its contents will change when attributes
   25.49 + * are annotated onto the Symbol. However this class depends on the facts that
   25.50 + * List (in javac) is immutable.
   25.51 + *
   25.52 + * An instance of this class can be in one of three states:
   25.53 + *
   25.54 + * NOT_STARTED indicates that the Symbol this instance belongs to has not been
   25.55 + * annotated (yet). Specifically if the declaration is not annotated this
   25.56 + * instance will never move past NOT_STARTED. You can never go back to
   25.57 + * NOT_STARTED.
   25.58 + *
   25.59 + * IN_PROGRESS annotations have been found on the declaration. Will be processed
   25.60 + * later. You can reset to IN_PROGRESS. While IN_PROGRESS you can set the list
   25.61 + * of attributes (and this moves out of the IN_PROGRESS state).
   25.62 + *
   25.63 + * "unnamed" this SymbolMetadata contains some attributes, possibly the final set.
   25.64 + * While in this state you can only prepend or append to the attributes not set
   25.65 + * it directly. You can also move back to the IN_PROGRESS state using reset().
   25.66 + *
   25.67 + * <p><b>This is NOT part of any supported API. If you write code that depends
   25.68 + * on this, you do so at your own risk. This code and its internal interfaces
   25.69 + * are subject to change or deletion without notice.</b>
   25.70 + */
   25.71 +public class SymbolMetadata {
   25.72 +
   25.73 +    private static final List<Attribute.Compound> DECL_NOT_STARTED = List.of(null);
   25.74 +    private static final List<Attribute.Compound> DECL_IN_PROGRESS = List.of(null);
   25.75 +
   25.76 +    /*
   25.77 +     * This field should never be null
   25.78 +     */
   25.79 +    private List<Attribute.Compound> attributes = DECL_NOT_STARTED;
   25.80 +
   25.81 +    /*
   25.82 +     * Type attributes for this symbol.
   25.83 +     * This field should never be null.
   25.84 +     */
   25.85 +    private List<Attribute.TypeCompound> type_attributes = List.<Attribute.TypeCompound>nil();
   25.86 +
   25.87 +    /*
   25.88 +     * Type attributes of initializers in this class.
   25.89 +     * Unused if the current symbol is not a ClassSymbol.
   25.90 +     */
   25.91 +    private List<Attribute.TypeCompound> init_type_attributes = List.<Attribute.TypeCompound>nil();
   25.92 +
   25.93 +    /*
   25.94 +     * Type attributes of class initializers in this class.
   25.95 +     * Unused if the current symbol is not a ClassSymbol.
   25.96 +     */
   25.97 +    private List<Attribute.TypeCompound> clinit_type_attributes = List.<Attribute.TypeCompound>nil();
   25.98 +
   25.99 +    /*
  25.100 +     * The Symbol this SymbolMetadata instance belongs to
  25.101 +     */
  25.102 +    private final Symbol sym;
  25.103 +
  25.104 +    public SymbolMetadata(Symbol sym) {
  25.105 +        this.sym = sym;
  25.106 +    }
  25.107 +
  25.108 +    public List<Attribute.Compound> getDeclarationAttributes() {
  25.109 +        return filterDeclSentinels(attributes);
  25.110 +    }
  25.111 +
  25.112 +    public List<Attribute.TypeCompound> getTypeAttributes() {
  25.113 +        return type_attributes;
  25.114 +    }
  25.115 +
  25.116 +    public List<Attribute.TypeCompound> getInitTypeAttributes() {
  25.117 +        return init_type_attributes;
  25.118 +    }
  25.119 +
  25.120 +    public List<Attribute.TypeCompound> getClassInitTypeAttributes() {
  25.121 +        return clinit_type_attributes;
  25.122 +    }
  25.123 +
  25.124 +    public void setDeclarationAttributes(List<Attribute.Compound> a) {
  25.125 +        Assert.check(pendingCompletion() || !isStarted());
  25.126 +        if (a == null) {
  25.127 +            throw new NullPointerException();
  25.128 +        }
  25.129 +        attributes = a;
  25.130 +    }
  25.131 +
  25.132 +    public void setTypeAttributes(List<Attribute.TypeCompound> a) {
  25.133 +        if (a == null) {
  25.134 +            throw new NullPointerException();
  25.135 +        }
  25.136 +        type_attributes = a;
  25.137 +    }
  25.138 +
  25.139 +    public void setInitTypeAttributes(List<Attribute.TypeCompound> a) {
  25.140 +        if (a == null) {
  25.141 +            throw new NullPointerException();
  25.142 +        }
  25.143 +        init_type_attributes = a;
  25.144 +    }
  25.145 +
  25.146 +    public void setClassInitTypeAttributes(List<Attribute.TypeCompound> a) {
  25.147 +        if (a == null) {
  25.148 +            throw new NullPointerException();
  25.149 +        }
  25.150 +        clinit_type_attributes = a;
  25.151 +    }
  25.152 +
  25.153 +    public void setAttributes(SymbolMetadata other) {
  25.154 +        if (other == null) {
  25.155 +            throw new NullPointerException();
  25.156 +        }
  25.157 +        setDeclarationAttributes(other.getDeclarationAttributes());
  25.158 +        setTypeAttributes(other.getTypeAttributes());
  25.159 +        setInitTypeAttributes(other.getInitTypeAttributes());
  25.160 +        setClassInitTypeAttributes(other.getClassInitTypeAttributes());
  25.161 +    }
  25.162 +
  25.163 +    public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.Compound> ctx) {
  25.164 +        Assert.check(pendingCompletion() || (!isStarted() && sym.kind == PCK));
  25.165 +        this.setDeclarationAttributes(getAttributesForCompletion(ctx));
  25.166 +    }
  25.167 +
  25.168 +    public void appendTypeAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.TypeCompound> ctx) {
  25.169 +        this.appendUniqueTypes(getAttributesForCompletion(ctx));
  25.170 +    }
  25.171 +
  25.172 +    private <T extends Attribute.Compound> List<T> getAttributesForCompletion(
  25.173 +            final Annotate.AnnotateRepeatedContext<T> ctx) {
  25.174 +
  25.175 +        Map<Symbol.TypeSymbol, ListBuffer<T>> annotated = ctx.annotated;
  25.176 +        boolean atLeastOneRepeated = false;
  25.177 +        List<T> buf = List.<T>nil();
  25.178 +        for (ListBuffer<T> lb : annotated.values()) {
  25.179 +            if (lb.size() == 1) {
  25.180 +                buf = buf.prepend(lb.first());
  25.181 +            } else { // repeated
  25.182 +                // This will break when other subtypes of Attributs.Compound
  25.183 +                // are introduced, because PlaceHolder is a subtype of TypeCompound.
  25.184 +                T res;
  25.185 +                @SuppressWarnings("unchecked")
  25.186 +                T ph = (T) new Placeholder<T>(ctx, lb.toList(), sym);
  25.187 +                res = ph;
  25.188 +                buf = buf.prepend(res);
  25.189 +                atLeastOneRepeated = true;
  25.190 +            }
  25.191 +        }
  25.192 +
  25.193 +        if (atLeastOneRepeated) {
  25.194 +            // The Symbol s is now annotated with a combination of
  25.195 +            // finished non-repeating annotations and placeholders for
  25.196 +            // repeating annotations.
  25.197 +            //
  25.198 +            // We need to do this in two passes because when creating
  25.199 +            // a container for a repeating annotation we must
  25.200 +            // guarantee that the @Repeatable on the
  25.201 +            // contained annotation is fully annotated
  25.202 +            //
  25.203 +            // The way we force this order is to do all repeating
  25.204 +            // annotations in a pass after all non-repeating are
  25.205 +            // finished. This will work because @Repeatable
  25.206 +            // is non-repeating and therefore will be annotated in the
  25.207 +            // fist pass.
  25.208 +
  25.209 +            // Queue a pass that will replace Attribute.Placeholders
  25.210 +            // with Attribute.Compound (made from synthesized containers).
  25.211 +            ctx.annotateRepeated(new Annotate.Annotator() {
  25.212 +                @Override
  25.213 +                public String toString() {
  25.214 +                    return "repeated annotation pass of: " + sym + " in: " + sym.owner;
  25.215 +                }
  25.216 +
  25.217 +                @Override
  25.218 +                public void enterAnnotation() {
  25.219 +                    complete(ctx);
  25.220 +                }
  25.221 +            });
  25.222 +        }
  25.223 +        // Add non-repeating attributes
  25.224 +        return buf.reverse();
  25.225 +    }
  25.226 +
  25.227 +    public SymbolMetadata reset() {
  25.228 +        attributes = DECL_IN_PROGRESS;
  25.229 +        return this;
  25.230 +    }
  25.231 +
  25.232 +    public boolean isEmpty() {
  25.233 +        return !isStarted()
  25.234 +                || pendingCompletion()
  25.235 +                || attributes.isEmpty();
  25.236 +    }
  25.237 +
  25.238 +    public boolean isTypesEmpty() {
  25.239 +        return type_attributes.isEmpty();
  25.240 +    }
  25.241 +
  25.242 +    public boolean pendingCompletion() {
  25.243 +        return attributes == DECL_IN_PROGRESS;
  25.244 +    }
  25.245 +
  25.246 +    public SymbolMetadata append(List<Attribute.Compound> l) {
  25.247 +        attributes = filterDeclSentinels(attributes);
  25.248 +
  25.249 +        if (l.isEmpty()) {
  25.250 +            ; // no-op
  25.251 +        } else if (attributes.isEmpty()) {
  25.252 +            attributes = l;
  25.253 +        } else {
  25.254 +            attributes = attributes.appendList(l);
  25.255 +        }
  25.256 +        return this;
  25.257 +    }
  25.258 +
  25.259 +    public SymbolMetadata appendUniqueTypes(List<Attribute.TypeCompound> l) {
  25.260 +        if (l.isEmpty()) {
  25.261 +            ; // no-op
  25.262 +        } else if (type_attributes.isEmpty()) {
  25.263 +            type_attributes = l;
  25.264 +        } else {
  25.265 +            // TODO: in case we expect a large number of annotations, this
  25.266 +            // might be inefficient.
  25.267 +            for (Attribute.TypeCompound tc : l) {
  25.268 +                if (!type_attributes.contains(tc))
  25.269 +                    type_attributes = type_attributes.append(tc);
  25.270 +            }
  25.271 +        }
  25.272 +        return this;
  25.273 +    }
  25.274 +
  25.275 +    public SymbolMetadata appendInitTypeAttributes(List<Attribute.TypeCompound> l) {
  25.276 +        if (l.isEmpty()) {
  25.277 +            ; // no-op
  25.278 +        } else if (init_type_attributes.isEmpty()) {
  25.279 +            init_type_attributes = l;
  25.280 +        } else {
  25.281 +            init_type_attributes = init_type_attributes.appendList(l);
  25.282 +        }
  25.283 +        return this;
  25.284 +    }
  25.285 +
  25.286 +    public SymbolMetadata appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {
  25.287 +        if (l.isEmpty()) {
  25.288 +            ; // no-op
  25.289 +        } else if (clinit_type_attributes.isEmpty()) {
  25.290 +            clinit_type_attributes = l;
  25.291 +        } else {
  25.292 +            clinit_type_attributes = clinit_type_attributes.appendList(l);
  25.293 +        }
  25.294 +        return this;
  25.295 +    }
  25.296 +
  25.297 +    public SymbolMetadata prepend(List<Attribute.Compound> l) {
  25.298 +        attributes = filterDeclSentinels(attributes);
  25.299 +
  25.300 +        if (l.isEmpty()) {
  25.301 +            ; // no-op
  25.302 +        } else if (attributes.isEmpty()) {
  25.303 +            attributes = l;
  25.304 +        } else {
  25.305 +            attributes = attributes.prependList(l);
  25.306 +        }
  25.307 +        return this;
  25.308 +    }
  25.309 +
  25.310 +    private List<Attribute.Compound> filterDeclSentinels(List<Attribute.Compound> a) {
  25.311 +        return (a == DECL_IN_PROGRESS || a == DECL_NOT_STARTED)
  25.312 +                ? List.<Attribute.Compound>nil()
  25.313 +                : a;
  25.314 +    }
  25.315 +
  25.316 +    private boolean isStarted() {
  25.317 +        return attributes != DECL_NOT_STARTED;
  25.318 +    }
  25.319 +
  25.320 +    private List<Attribute.Compound> getPlaceholders() {
  25.321 +        List<Attribute.Compound> res = List.<Attribute.Compound>nil();
  25.322 +        for (Attribute.Compound a : filterDeclSentinels(attributes)) {
  25.323 +            if (a instanceof Placeholder) {
  25.324 +                res = res.prepend(a);
  25.325 +            }
  25.326 +        }
  25.327 +        return res.reverse();
  25.328 +    }
  25.329 +
  25.330 +    private List<Attribute.TypeCompound> getTypePlaceholders() {
  25.331 +        List<Attribute.TypeCompound> res = List.<Attribute.TypeCompound>nil();
  25.332 +        for (Attribute.TypeCompound a : type_attributes) {
  25.333 +            if (a instanceof Placeholder) {
  25.334 +                res = res.prepend(a);
  25.335 +            }
  25.336 +        }
  25.337 +        return res.reverse();
  25.338 +    }
  25.339 +
  25.340 +    /*
  25.341 +     * Replace Placeholders for repeating annotations with their containers
  25.342 +     */
  25.343 +    private <T extends Attribute.Compound> void complete(Annotate.AnnotateRepeatedContext<T> ctx) {
  25.344 +        Log log = ctx.log;
  25.345 +        Env<AttrContext> env = ctx.env;
  25.346 +        JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);
  25.347 +        try {
  25.348 +            // TODO: can we reduce duplication in the following branches?
  25.349 +            if (ctx.isTypeCompound) {
  25.350 +                Assert.check(!isTypesEmpty());
  25.351 +
  25.352 +                if (isTypesEmpty()) {
  25.353 +                    return;
  25.354 +                }
  25.355 +
  25.356 +                List<Attribute.TypeCompound> result = List.nil();
  25.357 +                for (Attribute.TypeCompound a : getTypeAttributes()) {
  25.358 +                    if (a instanceof Placeholder) {
  25.359 +                        @SuppressWarnings("unchecked")
  25.360 +                        Placeholder<Attribute.TypeCompound> ph = (Placeholder<Attribute.TypeCompound>) a;
  25.361 +                        Attribute.TypeCompound replacement = replaceOne(ph, ph.getRepeatedContext());
  25.362 +
  25.363 +                        if (null != replacement) {
  25.364 +                            result = result.prepend(replacement);
  25.365 +                        }
  25.366 +                    } else {
  25.367 +                        result = result.prepend(a);
  25.368 +                    }
  25.369 +                }
  25.370 +
  25.371 +                type_attributes = result.reverse();
  25.372 +
  25.373 +                Assert.check(SymbolMetadata.this.getTypePlaceholders().isEmpty());
  25.374 +            } else {
  25.375 +                Assert.check(!pendingCompletion());
  25.376 +
  25.377 +                if (isEmpty()) {
  25.378 +                    return;
  25.379 +                }
  25.380 +
  25.381 +                List<Attribute.Compound> result = List.nil();
  25.382 +                for (Attribute.Compound a : getDeclarationAttributes()) {
  25.383 +                    if (a instanceof Placeholder) {
  25.384 +                        @SuppressWarnings("unchecked")
  25.385 +                        Attribute.Compound replacement = replaceOne((Placeholder<T>) a, ctx);
  25.386 +
  25.387 +                        if (null != replacement) {
  25.388 +                            result = result.prepend(replacement);
  25.389 +                        }
  25.390 +                    } else {
  25.391 +                        result = result.prepend(a);
  25.392 +                    }
  25.393 +                }
  25.394 +
  25.395 +                attributes = result.reverse();
  25.396 +
  25.397 +                Assert.check(SymbolMetadata.this.getPlaceholders().isEmpty());
  25.398 +            }
  25.399 +        } finally {
  25.400 +            log.useSource(oldSource);
  25.401 +        }
  25.402 +    }
  25.403 +
  25.404 +    private <T extends Attribute.Compound> T replaceOne(Placeholder<T> placeholder, Annotate.AnnotateRepeatedContext<T> ctx) {
  25.405 +        Log log = ctx.log;
  25.406 +
  25.407 +        // Process repeated annotations
  25.408 +        T validRepeated = ctx.processRepeatedAnnotations(placeholder.getPlaceholderFor(), sym);
  25.409 +
  25.410 +        if (validRepeated != null) {
  25.411 +            // Check that the container isn't manually
  25.412 +            // present along with repeated instances of
  25.413 +            // its contained annotation.
  25.414 +            ListBuffer<T> manualContainer = ctx.annotated.get(validRepeated.type.tsym);
  25.415 +            if (manualContainer != null) {
  25.416 +                log.error(ctx.pos.get(manualContainer.first()), "invalid.repeatable.annotation.repeated.and.container.present",
  25.417 +                        manualContainer.first().type.tsym);
  25.418 +            }
  25.419 +        }
  25.420 +
  25.421 +        // A null return will delete the Placeholder
  25.422 +        return validRepeated;
  25.423 +    }
  25.424 +
  25.425 +    private static class Placeholder<T extends Attribute.Compound> extends Attribute.TypeCompound {
  25.426 +
  25.427 +        private final Annotate.AnnotateRepeatedContext<T> ctx;
  25.428 +        private final List<T> placeholderFor;
  25.429 +        private final Symbol on;
  25.430 +
  25.431 +        public Placeholder(Annotate.AnnotateRepeatedContext<T> ctx, List<T> placeholderFor, Symbol on) {
  25.432 +            super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),
  25.433 +                    ctx.isTypeCompound ?
  25.434 +                            ((Attribute.TypeCompound)placeholderFor.head).position :
  25.435 +                                null);
  25.436 +            this.ctx = ctx;
  25.437 +            this.placeholderFor = placeholderFor;
  25.438 +            this.on = on;
  25.439 +        }
  25.440 +
  25.441 +        @Override
  25.442 +        public String toString() {
  25.443 +            return "<placeholder: " + placeholderFor + " on: " + on + ">";
  25.444 +        }
  25.445 +
  25.446 +        public List<T> getPlaceholderFor() {
  25.447 +            return placeholderFor;
  25.448 +        }
  25.449 +
  25.450 +        public Annotate.AnnotateRepeatedContext<T> getRepeatedContext() {
  25.451 +            return ctx;
  25.452 +        }
  25.453 +    }
  25.454 +}

    26.1 --- a/src/share/classes/com/sun/tools/javac/code/Types.java	Thu Sep 12 11:09:20 2013 -0700
    26.2 +++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Tue Sep 17 08:21:11 2013 -0700
    26.3 @@ -3055,7 +3055,7 @@
    26.4      /**
    26.5       * Does t have the same bounds for quantified variables as s?
    26.6       */
    26.7 -    boolean hasSameBounds(ForAll t, ForAll s) {
    26.8 +    public boolean hasSameBounds(ForAll t, ForAll s) {
    26.9          List<Type> l1 = t.tvars;
   26.10          List<Type> l2 = s.tvars;
   26.11          while (l1.nonEmpty() && l2.nonEmpty() &&

    27.1 --- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Thu Sep 12 11:09:20 2013 -0700
    27.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Sep 17 08:21:11 2013 -0700
    27.3 @@ -748,19 +748,11 @@
    27.4       *  @see VarSymbol#setLazyConstValue
    27.5       */
    27.6      public Object attribLazyConstantValue(Env<AttrContext> env,
    27.7 -                                      JCTree.JCExpression initializer,
    27.8 +                                      JCVariableDecl variable,
    27.9                                        Type type) {
   27.10  
   27.11 -        /*  When this env was created, it didn't have the correct lint nor had
   27.12 -         *  annotations has been processed.
   27.13 -         *  But now at this phase we have already processed annotations and the
   27.14 -         *  correct lint must have been set in chk, so we should use that one to
   27.15 -         *  attribute the initializer.
   27.16 -         */
   27.17 -        Lint prevLint = env.info.lint;
   27.18 -        env.info.lint = chk.getLint();
   27.19 -
   27.20 -        JavaFileObject prevSource = log.useSource(env.toplevel.sourcefile);
   27.21 +        DiagnosticPosition prevLintPos
   27.22 +                = deferredLintHandler.setPos(variable.pos());
   27.23  
   27.24          try {
   27.25              // Use null as symbol to not attach the type annotation to any symbol.
   27.26 @@ -768,17 +760,16 @@
   27.27              // to the symbol.
   27.28              // This prevents having multiple type annotations, just because of
   27.29              // lazy constant value evaluation.
   27.30 -            memberEnter.typeAnnotate(initializer, env, null);
   27.31 +            memberEnter.typeAnnotate(variable.init, env, null, variable.pos());
   27.32              annotate.flush();
   27.33 -            Type itype = attribExpr(initializer, env, type);
   27.34 +            Type itype = attribExpr(variable.init, env, type);
   27.35              if (itype.constValue() != null) {
   27.36                  return coerce(itype, type).constValue();
   27.37              } else {
   27.38                  return null;
   27.39              }
   27.40          } finally {
   27.41 -            env.info.lint = prevLint;
   27.42 -            log.useSource(prevSource);
   27.43 +            deferredLintHandler.setPos(prevLintPos);
   27.44          }
   27.45      }
   27.46  
   27.47 @@ -1012,7 +1003,7 @@
   27.48                  }
   27.49  
   27.50                  // Attribute all type annotations in the body
   27.51 -                memberEnter.typeAnnotate(tree.body, localEnv, m);
   27.52 +                memberEnter.typeAnnotate(tree.body, localEnv, m, null);
   27.53                  annotate.flush();
   27.54  
   27.55                  // Attribute method body.
   27.56 @@ -1042,7 +1033,7 @@
   27.57          } else {
   27.58              if (tree.init != null) {
   27.59                  // Field initializer expression need to be entered.
   27.60 -                memberEnter.typeAnnotate(tree.init, env, tree.sym);
   27.61 +                memberEnter.typeAnnotate(tree.init, env, tree.sym, tree.pos());
   27.62                  annotate.flush();
   27.63              }
   27.64          }
   27.65 @@ -1056,18 +1047,16 @@
   27.66                  ((JCLambda)env.tree).paramKind == JCLambda.ParameterKind.IMPLICIT &&
   27.67                  (tree.sym.flags() & PARAMETER) != 0;
   27.68          chk.validate(tree.vartype, env, !isImplicitLambdaParameter);
   27.69 -        deferredLintHandler.flush(tree.pos());
   27.70  
   27.71          try {
   27.72 +            v.getConstValue(); // ensure compile-time constant initializer is evaluated
   27.73 +            deferredLintHandler.flush(tree.pos());
   27.74              chk.checkDeprecatedAnnotation(tree.pos(), v);
   27.75  
   27.76              if (tree.init != null) {
   27.77 -                if ((v.flags_field & FINAL) != 0 &&
   27.78 -                    memberEnter.needsLazyConstValue(tree.init)) {
   27.79 -                    // In this case, `v' is final.  Ensure that it's initializer is
   27.80 -                    // evaluated.
   27.81 -                    v.getConstValue(); // ensure initializer is evaluated
   27.82 -                } else {
   27.83 +                if ((v.flags_field & FINAL) == 0 ||
   27.84 +                    !memberEnter.needsLazyConstValue(tree.init)) {
   27.85 +                    // Not a compile-time constant
   27.86                      // Attribute initializer in a new environment
   27.87                      // with the declared variable as owner.
   27.88                      // Check that initializer conforms to variable's declared type.
   27.89 @@ -1106,7 +1095,7 @@
   27.90              if ((tree.flags & STATIC) != 0) localEnv.info.staticLevel++;
   27.91  
   27.92              // Attribute all type annotations in the block
   27.93 -            memberEnter.typeAnnotate(tree, localEnv, localEnv.info.scope.owner);
   27.94 +            memberEnter.typeAnnotate(tree, localEnv, localEnv.info.scope.owner, null);
   27.95              annotate.flush();
   27.96  
   27.97              {
   27.98 @@ -2319,30 +2308,37 @@
   27.99          boolean needsRecovery =
  27.100                  resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK;
  27.101          try {
  27.102 -            Type target = pt();
  27.103 +            Type currentTarget = pt();
  27.104              List<Type> explicitParamTypes = null;
  27.105              if (that.paramKind == JCLambda.ParameterKind.EXPLICIT) {
  27.106                  //attribute lambda parameters
  27.107                  attribStats(that.params, localEnv);
  27.108                  explicitParamTypes = TreeInfo.types(that.params);
  27.109 -                target = infer.instantiateFunctionalInterface(that, target, explicitParamTypes, resultInfo.checkContext);
  27.110              }
  27.111  
  27.112              Type lambdaType;
  27.113              if (pt() != Type.recoveryType) {
  27.114 -                target = targetChecker.visit(target, that);
  27.115 -                lambdaType = types.findDescriptorType(target);
  27.116 +                /* We need to adjust the target. If the target is an
  27.117 +                 * intersection type, for example: SAM & I1 & I2 ...
  27.118 +                 * the target will be updated to SAM
  27.119 +                 */
  27.120 +                currentTarget = targetChecker.visit(currentTarget, that);
  27.121 +                if (explicitParamTypes != null) {
  27.122 +                    currentTarget = infer.instantiateFunctionalInterface(that,
  27.123 +                            currentTarget, explicitParamTypes, resultInfo.checkContext);
  27.124 +                }
  27.125 +                lambdaType = types.findDescriptorType(currentTarget);
  27.126              } else {
  27.127 -                target = Type.recoveryType;
  27.128 +                currentTarget = Type.recoveryType;
  27.129                  lambdaType = fallbackDescriptorType(that);
  27.130              }
  27.131  
  27.132 -            setFunctionalInfo(localEnv, that, pt(), lambdaType, target, resultInfo.checkContext);
  27.133 +            setFunctionalInfo(localEnv, that, pt(), lambdaType, currentTarget, resultInfo.checkContext);
  27.134  
  27.135              if (lambdaType.hasTag(FORALL)) {
  27.136                  //lambda expression target desc cannot be a generic method
  27.137                  resultInfo.checkContext.report(that, diags.fragment("invalid.generic.lambda.target",
  27.138 -                        lambdaType, kindName(target.tsym), target.tsym));
  27.139 +                        lambdaType, kindName(currentTarget.tsym), currentTarget.tsym));
  27.140                  result = that.type = types.createErrorType(pt());
  27.141                  return;
  27.142              }
  27.143 @@ -2376,7 +2372,7 @@
  27.144  
  27.145                  if (arityMismatch) {
  27.146                      resultInfo.checkContext.report(that, diags.fragment("incompatible.arg.types.in.lambda"));
  27.147 -                        result = that.type = types.createErrorType(target);
  27.148 +                        result = that.type = types.createErrorType(currentTarget);
  27.149                          return;
  27.150                  }
  27.151              }
  27.152 @@ -2396,38 +2392,14 @@
  27.153                  new ResultInfo(VAL, lambdaType.getReturnType(), funcContext);
  27.154              localEnv.info.returnResult = bodyResultInfo;
  27.155  
  27.156 -            Log.DeferredDiagnosticHandler lambdaDeferredHandler = new Log.DeferredDiagnosticHandler(log);
  27.157 -            try {
  27.158 -                if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
  27.159 -                    attribTree(that.getBody(), localEnv, bodyResultInfo);
  27.160 -                } else {
  27.161 -                    JCBlock body = (JCBlock)that.body;
  27.162 -                    attribStats(body.stats, localEnv);
  27.163 -                }
  27.164 -
  27.165 -                if (resultInfo.checkContext.deferredAttrContext().mode == AttrMode.SPECULATIVE) {
  27.166 -                    //check for errors in lambda body
  27.167 -                    for (JCDiagnostic deferredDiag : lambdaDeferredHandler.getDiagnostics()) {
  27.168 -                        if (deferredDiag.getKind() == JCDiagnostic.Kind.ERROR) {
  27.169 -                            resultInfo.checkContext
  27.170 -                                    .report(that, diags.fragment("bad.arg.types.in.lambda", TreeInfo.types(that.params),
  27.171 -                                    deferredDiag)); //hidden diag parameter
  27.172 -                            //we mark the lambda as erroneous - this is crucial in the recovery step
  27.173 -                            //as parameter-dependent type error won't be reported in that stage,
  27.174 -                            //meaning that a lambda will be deemed erroeneous only if there is
  27.175 -                            //a target-independent error (which will cause method diagnostic
  27.176 -                            //to be skipped).
  27.177 -                            result = that.type = types.createErrorType(target);
  27.178 -                            return;
  27.179 -                        }
  27.180 -                    }
  27.181 -                }
  27.182 -            } finally {
  27.183 -                lambdaDeferredHandler.reportDeferredDiagnostics();
  27.184 -                log.popDiagnosticHandler(lambdaDeferredHandler);
  27.185 +            if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
  27.186 +                attribTree(that.getBody(), localEnv, bodyResultInfo);
  27.187 +            } else {
  27.188 +                JCBlock body = (JCBlock)that.body;
  27.189 +                attribStats(body.stats, localEnv);
  27.190              }
  27.191  
  27.192 -            result = check(that, target, VAL, resultInfo);
  27.193 +            result = check(that, currentTarget, VAL, resultInfo);
  27.194  
  27.195              boolean isSpeculativeRound =
  27.196                      resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;
  27.197 @@ -2435,12 +2407,20 @@
  27.198              preFlow(that);
  27.199              flow.analyzeLambda(env, that, make, isSpeculativeRound);
  27.200  
  27.201 -            checkLambdaCompatible(that, lambdaType, resultInfo.checkContext, isSpeculativeRound);
  27.202 +            checkLambdaCompatible(that, lambdaType, resultInfo.checkContext);
  27.203  
  27.204              if (!isSpeculativeRound) {
  27.205 -                checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), lambdaType, target);
  27.206 +                //add thrown types as bounds to the thrown types free variables if needed:
  27.207 +                if (resultInfo.checkContext.inferenceContext().free(lambdaType.getThrownTypes())) {
  27.208 +                    List<Type> inferredThrownTypes = flow.analyzeLambdaThrownTypes(env, that, make);
  27.209 +                    List<Type> thrownTypes = resultInfo.checkContext.inferenceContext().asFree(lambdaType.getThrownTypes());
  27.210 +
  27.211 +                    chk.unhandled(inferredThrownTypes, thrownTypes);
  27.212 +                }
  27.213 +
  27.214 +                checkAccessibleTypes(that, localEnv, resultInfo.checkContext.inferenceContext(), lambdaType, currentTarget);
  27.215              }
  27.216 -            result = check(that, target, VAL, resultInfo);
  27.217 +            result = check(that, currentTarget, VAL, resultInfo);
  27.218          } catch (Types.FunctionDescriptorLookupError ex) {
  27.219              JCDiagnostic cause = ex.getDiagnostic();
  27.220              resultInfo.checkContext.report(that, cause);
  27.221 @@ -2604,10 +2584,9 @@
  27.222          * Lambda compatibility. Check that given return types, thrown types, parameter types
  27.223          * are compatible with the expected functional interface descriptor. This means that:
  27.224          * (i) parameter types must be identical to those of the target descriptor; (ii) return
  27.225 -        * types must be compatible with the return type of the expected descriptor;
  27.226 -        * (iii) finish inference of thrown types if required.
  27.227 +        * types must be compatible with the return type of the expected descriptor.
  27.228          */
  27.229 -        private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext, boolean speculativeAttr) {
  27.230 +        private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
  27.231              Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());
  27.232  
  27.233              //return values have already been checked - but if lambda has no return
  27.234 @@ -2624,11 +2603,6 @@
  27.235              if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
  27.236                  checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
  27.237              }
  27.238 -
  27.239 -            if (!speculativeAttr) {
  27.240 -                List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes());
  27.241 -                chk.unhandled(tree.inferredThrownTypes == null ? List.<Type>nil() : tree.inferredThrownTypes, thrownTypes);
  27.242 -            }
  27.243          }
  27.244  
  27.245          private Env<AttrContext> lambdaEnv(JCLambda that, Env<AttrContext> env) {
  27.246 @@ -2664,6 +2638,13 @@
  27.247  
  27.248              if (that.getMode() == JCMemberReference.ReferenceMode.NEW) {
  27.249                  exprType = chk.checkConstructorRefType(that.expr, exprType);
  27.250 +                if (!exprType.isErroneous() &&
  27.251 +                    exprType.isRaw() &&
  27.252 +                    that.typeargs != null) {
  27.253 +                    log.error(that.expr.pos(), "invalid.mref", Kinds.kindName(that.getMode()),
  27.254 +                        diags.fragment("mref.infer.and.explicit.params"));
  27.255 +                    exprType = types.createErrorType(exprType);
  27.256 +                }
  27.257              }
  27.258  
  27.259              if (exprType.isErroneous()) {
  27.260 @@ -3731,7 +3712,7 @@
  27.261       * Check that method arguments conform to its instantiation.
  27.262       **/
  27.263      public Type checkMethod(Type site,
  27.264 -                            Symbol sym,
  27.265 +                            final Symbol sym,
  27.266                              ResultInfo resultInfo,
  27.267                              Env<AttrContext> env,
  27.268                              final List<JCExpression> argtrees,
  27.269 @@ -3820,8 +3801,19 @@
  27.270              resultInfo.checkContext.report(env.tree.pos(), ex.getDiagnostic());
  27.271              return types.createErrorType(site);
  27.272          } catch (Resolve.InapplicableMethodException ex) {
  27.273 -            Assert.error(ex.getDiagnostic().getMessage(Locale.getDefault()));
  27.274 -            return null;
  27.275 +            final JCDiagnostic diag = ex.getDiagnostic();
  27.276 +            Resolve.InapplicableSymbolError errSym = rs.new InapplicableSymbolError(null) {
  27.277 +                @Override
  27.278 +                protected Pair<Symbol, JCDiagnostic> errCandidate() {
  27.279 +                    return new Pair<Symbol, JCDiagnostic>(sym, diag);
  27.280 +                }
  27.281 +            };
  27.282 +            List<Type> argtypes2 = Type.map(argtypes,
  27.283 +                    rs.new ResolveDeferredRecoveryMap(AttrMode.CHECK, sym, env.info.pendingResolutionPhase));
  27.284 +            JCDiagnostic errDiag = errSym.getDiagnostic(JCDiagnostic.DiagnosticType.ERROR,
  27.285 +                    env.tree, sym, site, sym.name, argtypes2, typeargtypes);
  27.286 +            log.report(errDiag);
  27.287 +            return types.createErrorType(site);
  27.288          }
  27.289      }
  27.290  
  27.291 @@ -4206,6 +4198,7 @@
  27.292              ResultInfo prevReturnRes = env.info.returnResult;
  27.293  
  27.294              try {
  27.295 +                deferredLintHandler.flush(env.tree);
  27.296                  env.info.returnResult = null;
  27.297                  // java.lang.Enum may not be subclassed by a non-enum
  27.298                  if (st.tsym == syms.enumSym &&

    28.1 --- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Thu Sep 12 11:09:20 2013 -0700
    28.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Tue Sep 17 08:21:11 2013 -0700
    28.3 @@ -148,7 +148,7 @@
    28.4          sunApiHandler = new MandatoryWarningHandler(log, verboseSunApi,
    28.5                  enforceMandatoryWarnings, "sunapi", null);
    28.6  
    28.7 -        deferredLintHandler = DeferredLintHandler.immediateHandler;
    28.8 +        deferredLintHandler = DeferredLintHandler.instance(context);
    28.9      }
   28.10  
   28.11      /** Switch: generics enabled?
   28.12 @@ -218,20 +218,6 @@
   28.13          return prev;
   28.14      }
   28.15  
   28.16 -    /*  This idiom should be used only in cases when it is needed to set the lint
   28.17 -     *  of an environment that has been created in a phase previous to annotations
   28.18 -     *  processing.
   28.19 -     */
   28.20 -    Lint getLint() {
   28.21 -        return lint;
   28.22 -    }
   28.23 -
   28.24 -    DeferredLintHandler setDeferredLintHandler(DeferredLintHandler newDeferredLintHandler) {
   28.25 -        DeferredLintHandler prev = deferredLintHandler;
   28.26 -        deferredLintHandler = newDeferredLintHandler;
   28.27 -        return prev;
   28.28 -    }
   28.29 -
   28.30      MethodSymbol setMethod(MethodSymbol newMethod) {
   28.31          MethodSymbol prev = method;
   28.32          method = newMethod;
   28.33 @@ -582,14 +568,19 @@
   28.34      /** Check for redundant casts (i.e. where source type is a subtype of target type)
   28.35       * The problem should only be reported for non-292 cast
   28.36       */
   28.37 -    public void checkRedundantCast(Env<AttrContext> env, JCTypeCast tree) {
   28.38 -        if (!tree.type.isErroneous() &&
   28.39 -                (env.info.lint == null || env.info.lint.isEnabled(Lint.LintCategory.CAST))
   28.40 +    public void checkRedundantCast(Env<AttrContext> env, final JCTypeCast tree) {
   28.41 +        if (!tree.type.isErroneous()
   28.42                  && types.isSameType(tree.expr.type, tree.clazz.type)
   28.43                  && !(ignoreAnnotatedCasts && TreeInfo.containsTypeAnnotation(tree.clazz))
   28.44                  && !is292targetTypeCast(tree)) {
   28.45 -            log.warning(Lint.LintCategory.CAST,
   28.46 -                    tree.pos(), "redundant.cast", tree.expr.type);
   28.47 +            deferredLintHandler.report(new DeferredLintHandler.LintLogger() {
   28.48 +                @Override
   28.49 +                public void report() {
   28.50 +                    if (lint.isEnabled(Lint.LintCategory.CAST))
   28.51 +                        log.warning(Lint.LintCategory.CAST,
   28.52 +                                tree.pos(), "redundant.cast", tree.expr.type);
   28.53 +                }
   28.54 +            });
   28.55          }
   28.56      }
   28.57      //where
   28.58 @@ -1050,6 +1041,7 @@
   28.59      long checkFlags(DiagnosticPosition pos, long flags, Symbol sym, JCTree tree) {
   28.60          long mask;
   28.61          long implicit = 0;
   28.62 +
   28.63          switch (sym.kind) {
   28.64          case VAR:
   28.65              if (sym.owner.kind != TYP)
   28.66 @@ -1070,7 +1062,10 @@
   28.67                  } else
   28.68                      mask = ConstructorFlags;
   28.69              }  else if ((sym.owner.flags_field & INTERFACE) != 0) {
   28.70 -                if ((flags & (DEFAULT | STATIC)) != 0) {
   28.71 +                if ((sym.owner.flags_field & ANNOTATION) != 0) {
   28.72 +                    mask = AnnotationTypeElementMask;
   28.73 +                    implicit = PUBLIC | ABSTRACT;
   28.74 +                } else if ((flags & (DEFAULT | STATIC)) != 0) {
   28.75                      mask = InterfaceMethodMask;
   28.76                      implicit = PUBLIC;
   28.77                      if ((flags & DEFAULT) != 0) {
   28.78 @@ -1079,8 +1074,7 @@
   28.79                  } else {
   28.80                      mask = implicit = InterfaceMethodFlags;
   28.81                  }
   28.82 -            }
   28.83 -            else {
   28.84 +            } else {
   28.85                  mask = MethodFlags;
   28.86              }
   28.87              // Imply STRICTFP if owner has STRICTFP set.
   28.88 @@ -2368,7 +2362,10 @@
   28.89          //for each method m1 that is overridden (directly or indirectly)
   28.90          //by method 'sym' in 'site'...
   28.91          for (Symbol m1 : types.membersClosure(site, false).getElementsByName(sym.name, cf)) {
   28.92 -            if (!sym.overrides(m1, site.tsym, types, false)) continue;
   28.93 +             if (!sym.overrides(m1, site.tsym, types, false)) {
   28.94 +                 checkPotentiallyAmbiguousOverloads(pos, site, sym, (MethodSymbol)m1);
   28.95 +                 continue;
   28.96 +             }
   28.97               //...check each method m2 that is a member of 'site'
   28.98               for (Symbol m2 : types.membersClosure(site, false).getElementsByName(sym.name, cf)) {
   28.99                  if (m2 == m1) continue;
  28.100 @@ -2406,14 +2403,17 @@
  28.101          for (Symbol s : types.membersClosure(site, true).getElementsByName(sym.name, cf)) {
  28.102              //if (i) the signature of 'sym' is not a subsignature of m1 (seen as
  28.103              //a member of 'site') and (ii) 'sym' has the same erasure as m1, issue an error
  28.104 -            if (!types.isSubSignature(sym.type, types.memberType(site, s), allowStrictMethodClashCheck) &&
  28.105 -                    types.hasSameArgs(s.erasure(types), sym.erasure(types))) {
  28.106 -                log.error(pos,
  28.107 -                        "name.clash.same.erasure.no.hide",
  28.108 -                        sym, sym.location(),
  28.109 -                        s, s.location());
  28.110 -                return;
  28.111 -             }
  28.112 +            if (!types.isSubSignature(sym.type, types.memberType(site, s), allowStrictMethodClashCheck)) {
  28.113 +                if (types.hasSameArgs(s.erasure(types), sym.erasure(types))) {
  28.114 +                    log.error(pos,
  28.115 +                            "name.clash.same.erasure.no.hide",
  28.116 +                            sym, sym.location(),
  28.117 +                            s, s.location());
  28.118 +                    return;
  28.119 +                } else {
  28.120 +                    checkPotentiallyAmbiguousOverloads(pos, site, sym, (MethodSymbol)s);
  28.121 +                }
  28.122 +            }
  28.123           }
  28.124       }
  28.125  
  28.126 @@ -2496,6 +2496,62 @@
  28.127           }
  28.128       }
  28.129  
  28.130 +    /**
  28.131 +      * Report warnings for potentially ambiguous method declarations. Two declarations
  28.132 +      * are potentially ambiguous if they feature two unrelated functional interface
  28.133 +      * in same argument position (in which case, a call site passing an implicit
  28.134 +      * lambda would be ambiguous).
  28.135 +      */
  28.136 +    void checkPotentiallyAmbiguousOverloads(DiagnosticPosition pos, Type site,
  28.137 +            MethodSymbol msym1, MethodSymbol msym2) {
  28.138 +        if (msym1 != msym2 &&
  28.139 +                allowDefaultMethods &&
  28.140 +                lint.isEnabled(LintCategory.OVERLOADS) &&
  28.141 +                (msym1.flags() & POTENTIALLY_AMBIGUOUS) == 0 &&
  28.142 +                (msym2.flags() & POTENTIALLY_AMBIGUOUS) == 0) {
  28.143 +            Type mt1 = types.memberType(site, msym1);
  28.144 +            Type mt2 = types.memberType(site, msym2);
  28.145 +            //if both generic methods, adjust type variables
  28.146 +            if (mt1.hasTag(FORALL) && mt2.hasTag(FORALL) &&
  28.147 +                    types.hasSameBounds((ForAll)mt1, (ForAll)mt2)) {
  28.148 +                mt2 = types.subst(mt2, ((ForAll)mt2).tvars, ((ForAll)mt1).tvars);
  28.149 +            }
  28.150 +            //expand varargs methods if needed
  28.151 +            int maxLength = Math.max(mt1.getParameterTypes().length(), mt2.getParameterTypes().length());
  28.152 +            List<Type> args1 = rs.adjustArgs(mt1.getParameterTypes(), msym1, maxLength, true);
  28.153 +            List<Type> args2 = rs.adjustArgs(mt2.getParameterTypes(), msym2, maxLength, true);
  28.154 +            //if arities don't match, exit
  28.155 +            if (args1.length() != args2.length()) return;
  28.156 +            boolean potentiallyAmbiguous = false;
  28.157 +            while (args1.nonEmpty() && args2.nonEmpty()) {
  28.158 +                Type s = args1.head;
  28.159 +                Type t = args2.head;
  28.160 +                if (!types.isSubtype(t, s) && !types.isSubtype(s, t)) {
  28.161 +                    if (types.isFunctionalInterface(s) && types.isFunctionalInterface(t) &&
  28.162 +                            types.findDescriptorType(s).getParameterTypes().length() > 0 &&
  28.163 +                            types.findDescriptorType(s).getParameterTypes().length() ==
  28.164 +                            types.findDescriptorType(t).getParameterTypes().length()) {
  28.165 +                        potentiallyAmbiguous = true;
  28.166 +                    } else {
  28.167 +                        break;
  28.168 +                    }
  28.169 +                }
  28.170 +                args1 = args1.tail;
  28.171 +                args2 = args2.tail;
  28.172 +            }
  28.173 +            if (potentiallyAmbiguous) {
  28.174 +                //we found two incompatible functional interfaces with same arity
  28.175 +                //this means a call site passing an implicit lambda would be ambigiuous
  28.176 +                msym1.flags_field |= POTENTIALLY_AMBIGUOUS;
  28.177 +                msym2.flags_field |= POTENTIALLY_AMBIGUOUS;
  28.178 +                log.warning(LintCategory.OVERLOADS, pos, "potentially.ambiguous.overload",
  28.179 +                            msym1, msym1.location(),
  28.180 +                            msym2, msym2.location());
  28.181 +                return;
  28.182 +            }
  28.183 +        }
  28.184 +    }
  28.185 +
  28.186      /** Report a conflict between a user symbol and a synthetic symbol.
  28.187       */
  28.188      private void syntheticError(DiagnosticPosition pos, Symbol sym) {
  28.189 @@ -3275,7 +3331,9 @@
  28.190                      (e.sym.flags() & CLASH) == 0 &&
  28.191                      sym.kind == e.sym.kind &&
  28.192                      sym.name != names.error &&
  28.193 -                    (sym.kind != MTH || types.hasSameArgs(types.erasure(sym.type), types.erasure(e.sym.type)))) {
  28.194 +                    (sym.kind != MTH ||
  28.195 +                     types.hasSameArgs(sym.type, e.sym.type) ||
  28.196 +                     types.hasSameArgs(types.erasure(sym.type), types.erasure(e.sym.type)))) {
  28.197                  if ((sym.flags() & VARARGS) != (e.sym.flags() & VARARGS)) {
  28.198                      varargsDuplicateError(pos, sym, e.sym);
  28.199                      return true;

    29.1 --- a/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Thu Sep 12 11:09:20 2013 -0700
    29.2 +++ b/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Tue Sep 17 08:21:11 2013 -0700
    29.3 @@ -25,6 +25,7 @@
    29.4  
    29.5  package com.sun.tools.javac.comp;
    29.6  
    29.7 +import com.sun.source.tree.MemberReferenceTree;
    29.8  import com.sun.tools.javac.code.*;
    29.9  import com.sun.tools.javac.tree.*;
   29.10  import com.sun.tools.javac.util.*;
   29.11 @@ -39,7 +40,9 @@
   29.12  
   29.13  
   29.14  import java.util.ArrayList;
   29.15 +import java.util.Collections;
   29.16  import java.util.EnumSet;
   29.17 +import java.util.LinkedHashMap;
   29.18  import java.util.LinkedHashSet;
   29.19  import java.util.Map;
   29.20  import java.util.Set;
   29.21 @@ -98,7 +101,7 @@
   29.22          emptyDeferredAttrContext =
   29.23              new DeferredAttrContext(AttrMode.CHECK, null, MethodResolutionPhase.BOX, infer.emptyContext, null, null) {
   29.24                  @Override
   29.25 -                void addDeferredAttrNode(DeferredType dt, ResultInfo ri, List<Type> stuckVars) {
   29.26 +                void addDeferredAttrNode(DeferredType dt, ResultInfo ri, DeferredStuckPolicy deferredStuckPolicy) {
   29.27                      Assert.error("Empty deferred context!");
   29.28                  }
   29.29                  @Override
   29.30 @@ -149,15 +152,15 @@
   29.31  
   29.32              class Entry {
   29.33                  JCTree speculativeTree;
   29.34 -                Resolve.MethodResolutionPhase phase;
   29.35 +                ResultInfo resultInfo;
   29.36  
   29.37 -                public Entry(JCTree speculativeTree, MethodResolutionPhase phase) {
   29.38 +                public Entry(JCTree speculativeTree, ResultInfo resultInfo) {
   29.39                      this.speculativeTree = speculativeTree;
   29.40 -                    this.phase = phase;
   29.41 +                    this.resultInfo = resultInfo;
   29.42                  }
   29.43  
   29.44 -                boolean matches(Resolve.MethodResolutionPhase phase) {
   29.45 -                    return this.phase == phase;
   29.46 +                boolean matches(MethodResolutionPhase phase) {
   29.47 +                    return resultInfo.checkContext.deferredAttrContext().phase == phase;
   29.48                  }
   29.49              }
   29.50  
   29.51 @@ -178,12 +181,13 @@
   29.52               * Stores a speculative cache entry corresponding to given symbol
   29.53               * and resolution phase
   29.54               */
   29.55 -            void put(Symbol msym, JCTree speculativeTree, MethodResolutionPhase phase) {
   29.56 +            void put(JCTree speculativeTree, ResultInfo resultInfo) {
   29.57 +                Symbol msym = resultInfo.checkContext.deferredAttrContext().msym;
   29.58                  List<Entry> entries = cache.get(msym);
   29.59                  if (entries == null) {
   29.60                      entries = List.nil();
   29.61                  }
   29.62 -                cache.put(msym, entries.prepend(new Entry(speculativeTree, phase)));
   29.63 +                cache.put(msym, entries.prepend(new Entry(speculativeTree, resultInfo)));
   29.64              }
   29.65          }
   29.66  
   29.67 @@ -203,15 +207,24 @@
   29.68           * attribution round must follow one or more speculative rounds.
   29.69           */
   29.70          Type check(ResultInfo resultInfo) {
   29.71 -            return check(resultInfo, stuckVars(tree, env, resultInfo), basicCompleter);
   29.72 +            DeferredStuckPolicy deferredStuckPolicy;
   29.73 +            if (resultInfo.pt.hasTag(NONE) || resultInfo.pt.isErroneous()) {
   29.74 +                deferredStuckPolicy = dummyStuckPolicy;
   29.75 +            } else if (resultInfo.checkContext.deferredAttrContext().mode == AttrMode.SPECULATIVE) {
   29.76 +                deferredStuckPolicy = new OverloadStuckPolicy(resultInfo, this);
   29.77 +            } else {
   29.78 +                deferredStuckPolicy = new CheckStuckPolicy(resultInfo, this);
   29.79 +            }
   29.80 +            return check(resultInfo, deferredStuckPolicy, basicCompleter);
   29.81          }
   29.82  
   29.83 -        Type check(ResultInfo resultInfo, List<Type> stuckVars, DeferredTypeCompleter deferredTypeCompleter) {
   29.84 +        private Type check(ResultInfo resultInfo, DeferredStuckPolicy deferredStuckPolicy,
   29.85 +                DeferredTypeCompleter deferredTypeCompleter) {
   29.86              DeferredAttrContext deferredAttrContext =
   29.87                      resultInfo.checkContext.deferredAttrContext();
   29.88              Assert.check(deferredAttrContext != emptyDeferredAttrContext);
   29.89 -            if (stuckVars.nonEmpty()) {
   29.90 -                deferredAttrContext.addDeferredAttrNode(this, resultInfo, stuckVars);
   29.91 +            if (deferredStuckPolicy.isStuck()) {
   29.92 +                deferredAttrContext.addDeferredAttrNode(this, resultInfo, deferredStuckPolicy);
   29.93                  return Type.noType;
   29.94              } else {
   29.95                  try {
   29.96 @@ -236,6 +249,7 @@
   29.97          Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext);
   29.98      }
   29.99  
  29.100 +
  29.101      /**
  29.102       * A basic completer for deferred types. This completer type-checks a deferred type
  29.103       * using attribution; depending on the attribution mode, this could be either standard
  29.104 @@ -249,7 +263,7 @@
  29.105                      //speculative rounds...
  29.106                      Assert.check(dt.mode == null || dt.mode == AttrMode.SPECULATIVE);
  29.107                      JCTree speculativeTree = attribSpeculative(dt.tree, dt.env, resultInfo);
  29.108 -                    dt.speculativeCache.put(deferredAttrContext.msym, speculativeTree, deferredAttrContext.phase);
  29.109 +                    dt.speculativeCache.put(speculativeTree, resultInfo);
  29.110                      return speculativeTree.type;
  29.111                  case CHECK:
  29.112                      Assert.check(dt.mode != null);
  29.113 @@ -268,6 +282,45 @@
  29.114      };
  29.115  
  29.116      /**
  29.117 +     * Policy for detecting stuck expressions. Different criteria might cause
  29.118 +     * an expression to be judged as stuck, depending on whether the check
  29.119 +     * is performed during overload resolution or after most specific.
  29.120 +     */
  29.121 +    interface DeferredStuckPolicy {
  29.122 +        /**
  29.123 +         * Has the policy detected that a given expression should be considered stuck?
  29.124 +         */
  29.125 +        boolean isStuck();
  29.126 +        /**
  29.127 +         * Get the set of inference variables a given expression depends upon.
  29.128 +         */
  29.129 +        Set<Type> stuckVars();
  29.130 +        /**
  29.131 +         * Get the set of inference variables which might get new constraints
  29.132 +         * if a given expression is being type-checked.
  29.133 +         */
  29.134 +        Set<Type> depVars();
  29.135 +    }
  29.136 +
  29.137 +    /**
  29.138 +     * Basic stuck policy; an expression is never considered to be stuck.
  29.139 +     */
  29.140 +    DeferredStuckPolicy dummyStuckPolicy = new DeferredStuckPolicy() {
  29.141 +        @Override
  29.142 +        public boolean isStuck() {
  29.143 +            return false;
  29.144 +        }
  29.145 +        @Override
  29.146 +        public Set<Type> stuckVars() {
  29.147 +            return Collections.emptySet();
  29.148 +        }
  29.149 +        @Override
  29.150 +        public Set<Type> depVars() {
  29.151 +            return Collections.emptySet();
  29.152 +        }
  29.153 +    };
  29.154 +
  29.155 +    /**
  29.156       * The 'mode' in which the deferred type is to be type-checked
  29.157       */
  29.158      public enum AttrMode {
  29.159 @@ -388,8 +441,9 @@
  29.160           * Adds a node to the list of deferred attribution nodes - used by Resolve.rawCheckArgumentsApplicable
  29.161           * Nodes added this way act as 'roots' for the out-of-order method checking process.
  29.162           */
  29.163 -        void addDeferredAttrNode(final DeferredType dt, ResultInfo resultInfo, List<Type> stuckVars) {
  29.164 -            deferredAttrNodes.add(new DeferredAttrNode(dt, resultInfo, stuckVars));
  29.165 +        void addDeferredAttrNode(final DeferredType dt, ResultInfo resultInfo,
  29.166 +                DeferredStuckPolicy deferredStuckPolicy) {
  29.167 +            deferredAttrNodes.add(new DeferredAttrNode(dt, resultInfo, deferredStuckPolicy));
  29.168          }
  29.169  
  29.170          /**
  29.171 @@ -400,23 +454,52 @@
  29.172           */
  29.173          void complete() {
  29.174              while (!deferredAttrNodes.isEmpty()) {
  29.175 -                Set<Type> stuckVars = new LinkedHashSet<Type>();
  29.176 +                Map<Type, Set<Type>> depVarsMap = new LinkedHashMap<Type, Set<Type>>();
  29.177 +                List<Type> stuckVars = List.nil();
  29.178                  boolean progress = false;
  29.179                  //scan a defensive copy of the node list - this is because a deferred
  29.180                  //attribution round can add new nodes to the list
  29.181                  for (DeferredAttrNode deferredAttrNode : List.from(deferredAttrNodes)) {
  29.182                      if (!deferredAttrNode.process(this)) {
  29.183 -                        stuckVars.addAll(deferredAttrNode.stuckVars);
  29.184 +                        List<Type> restStuckVars =
  29.185 +                                List.from(deferredAttrNode.deferredStuckPolicy.stuckVars())
  29.186 +                                .intersect(inferenceContext.restvars());
  29.187 +                        stuckVars = stuckVars.prependList(restStuckVars);
  29.188 +                        //update dependency map
  29.189 +                        for (Type t : List.from(deferredAttrNode.deferredStuckPolicy.depVars())
  29.190 +                                .intersect(inferenceContext.restvars())) {
  29.191 +                            Set<Type> prevDeps = depVarsMap.get(t);
  29.192 +                            if (prevDeps == null) {
  29.193 +                                prevDeps = new LinkedHashSet<Type>();
  29.194 +                                depVarsMap.put(t, prevDeps);
  29.195 +                            }
  29.196 +                            prevDeps.addAll(restStuckVars);
  29.197 +                        }
  29.198                      } else {
  29.199                          deferredAttrNodes.remove(deferredAttrNode);
  29.200                          progress = true;
  29.201                      }
  29.202                  }
  29.203                  if (!progress) {
  29.204 +                    DeferredAttrContext dac = this;
  29.205 +                    while (dac != emptyDeferredAttrContext) {
  29.206 +                        if (dac.mode == AttrMode.SPECULATIVE) {
  29.207 +                            //unsticking does not take place during overload
  29.208 +                            break;
  29.209 +                        }
  29.210 +                        dac = dac.parent;
  29.211 +                    }
  29.212                      //remove all variables that have already been instantiated
  29.213                      //from the list of stuck variables
  29.214 -                    inferenceContext.solveAny(List.from(stuckVars), warn);
  29.215 -                    inferenceContext.notifyChange();
  29.216 +                    try {
  29.217 +                        inferenceContext.solveAny(stuckVars, depVarsMap, warn);
  29.218 +                        inferenceContext.notifyChange();
  29.219 +                    } catch (Infer.GraphStrategy.NodeNotFoundException ex) {
  29.220 +                        //this means that we are in speculative mode and the
  29.221 +                        //set of contraints are too tight for progess to be made.
  29.222 +                        //Just leave the remaining expressions as stuck.
  29.223 +                        break;
  29.224 +                    }
  29.225                  }
  29.226              }
  29.227          }
  29.228 @@ -426,7 +509,7 @@
  29.229       * Class representing a deferred attribution node. It keeps track of
  29.230       * a deferred type, along with the expected target type information.
  29.231       */
  29.232 -    class DeferredAttrNode implements Infer.FreeTypeListener {
  29.233 +    class DeferredAttrNode {
  29.234  
  29.235          /** underlying deferred type */
  29.236          DeferredType dt;
  29.237 @@ -434,22 +517,13 @@
  29.238          /** underlying target type information */
  29.239          ResultInfo resultInfo;
  29.240  
  29.241 -        /** list of uninferred inference variables causing this node to be stuck */
  29.242 -        List<Type> stuckVars;
  29.243 +        /** stuck policy associated with this node */
  29.244 +        DeferredStuckPolicy deferredStuckPolicy;
  29.245  
  29.246 -        DeferredAttrNode(DeferredType dt, ResultInfo resultInfo, List<Type> stuckVars) {
  29.247 +        DeferredAttrNode(DeferredType dt, ResultInfo resultInfo, DeferredStuckPolicy deferredStuckPolicy) {
  29.248              this.dt = dt;
  29.249              this.resultInfo = resultInfo;
  29.250 -            this.stuckVars = stuckVars;
  29.251 -            if (!stuckVars.isEmpty()) {
  29.252 -                resultInfo.checkContext.inferenceContext().addFreeTypeListener(stuckVars, this);
  29.253 -            }
  29.254 -        }
  29.255 -
  29.256 -        @Override
  29.257 -        public void typesInferred(InferenceContext inferenceContext) {
  29.258 -            stuckVars = List.nil();
  29.259 -            resultInfo = resultInfo.dup(inferenceContext.asInstType(resultInfo.pt));
  29.260 +            this.deferredStuckPolicy = deferredStuckPolicy;
  29.261          }
  29.262  
  29.263          /**
  29.264 @@ -457,24 +531,41 @@
  29.265           * Invariant: a stuck node cannot be processed.
  29.266           */
  29.267          @SuppressWarnings("fallthrough")
  29.268 -        boolean process(DeferredAttrContext deferredAttrContext) {
  29.269 +        boolean process(final DeferredAttrContext deferredAttrContext) {
  29.270              switch (deferredAttrContext.mode) {
  29.271                  case SPECULATIVE:
  29.272 -                    dt.check(resultInfo, List.<Type>nil(), new StructuralStuckChecker());
  29.273 -                    return true;
  29.274 +                    if (deferredStuckPolicy.isStuck()) {
  29.275 +                        dt.check(resultInfo, dummyStuckPolicy, new StructuralStuckChecker());
  29.276 +                        return true;
  29.277 +                    } else {
  29.278 +                        Assert.error("Cannot get here");
  29.279 +                    }
  29.280                  case CHECK:
  29.281 -                    if (stuckVars.nonEmpty()) {
  29.282 +                    if (deferredStuckPolicy.isStuck()) {
  29.283                          //stuck expression - see if we can propagate
  29.284                          if (deferredAttrContext.parent != emptyDeferredAttrContext &&
  29.285 -                                Type.containsAny(deferredAttrContext.parent.inferenceContext.inferencevars, List.from(stuckVars))) {
  29.286 -                            deferredAttrContext.parent.deferredAttrNodes.add(this);
  29.287 -                            dt.check(resultInfo, List.<Type>nil(), dummyCompleter);
  29.288 +                                Type.containsAny(deferredAttrContext.parent.inferenceContext.inferencevars,
  29.289 +                                        List.from(deferredStuckPolicy.stuckVars()))) {
  29.290 +                            deferredAttrContext.parent.addDeferredAttrNode(dt,
  29.291 +                                    resultInfo.dup(new Check.NestedCheckContext(resultInfo.checkContext) {
  29.292 +                                @Override
  29.293 +                                public InferenceContext inferenceContext() {
  29.294 +                                    return deferredAttrContext.parent.inferenceContext;
  29.295 +                                }
  29.296 +                                @Override
  29.297 +                                public DeferredAttrContext deferredAttrContext() {
  29.298 +                                    return deferredAttrContext.parent;
  29.299 +                                }
  29.300 +                            }), deferredStuckPolicy);
  29.301 +                            dt.tree.type = Type.stuckType;
  29.302                              return true;
  29.303                          } else {
  29.304                              return false;
  29.305                          }
  29.306                      } else {
  29.307 -                        dt.check(resultInfo, stuckVars, basicCompleter);
  29.308 +                        ResultInfo instResultInfo =
  29.309 +                                resultInfo.dup(deferredAttrContext.inferenceContext.asInstType(resultInfo.pt));
  29.310 +                        dt.check(instResultInfo, dummyStuckPolicy, basicCompleter);
  29.311                          return true;
  29.312                      }
  29.313                  default:
  29.314 @@ -489,12 +580,14 @@
  29.315  
  29.316              ResultInfo resultInfo;
  29.317              InferenceContext inferenceContext;
  29.318 +            Env<AttrContext> env;
  29.319  
  29.320              public Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
  29.321                  this.resultInfo = resultInfo;
  29.322                  this.inferenceContext = deferredAttrContext.inferenceContext;
  29.323 +                this.env = dt.env;
  29.324                  dt.tree.accept(this);
  29.325 -                dt.speculativeCache.put(deferredAttrContext.msym, stuckTree, deferredAttrContext.phase);
  29.326 +                dt.speculativeCache.put(stuckTree, resultInfo);
  29.327                  return Type.noType;
  29.328              }
  29.329  
  29.330 @@ -541,15 +634,25 @@
  29.331                      } catch (Types.FunctionDescriptorLookupError ex) {
  29.332                          checkContext.report(null, ex.getDiagnostic());
  29.333                      }
  29.334 -                    switch (tree.sym.kind) {
  29.335 +                    Env<AttrContext> localEnv = env.dup(tree);
  29.336 +                    JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
  29.337 +                            attr.memberReferenceQualifierResult(tree));
  29.338 +                    ListBuffer<Type> argtypes = ListBuffer.lb();
  29.339 +                    for (Type t : types.findDescriptorType(pt).getParameterTypes()) {
  29.340 +                        argtypes.append(Type.noType);
  29.341 +                    }
  29.342 +                    JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
  29.343 +                    mref2.expr = exprTree;
  29.344 +                    Pair<Symbol, ?> lookupRes =
  29.345 +                            rs.resolveMemberReference(tree, localEnv, mref2, exprTree.type,
  29.346 +                                tree.name, argtypes.toList(), null, true, rs.arityMethodCheck, inferenceContext);
  29.347 +                    switch (lookupRes.fst.kind) {
  29.348                          //note: as argtypes are erroneous types, type-errors must
  29.349                          //have been caused by arity mismatch
  29.350                          case Kinds.ABSENT_MTH:
  29.351                          case Kinds.WRONG_MTH:
  29.352                          case Kinds.WRONG_MTHS:
  29.353 -                        case Kinds.STATICERR:
  29.354 -                        case Kinds.MISSING_ENCL:
  29.355 -                           checkContext.report(null, diags.fragment("incompatible.arg.types.in.mref"));
  29.356 +                           checkContext.report(tree, diags.fragment("incompatible.arg.types.in.mref"));
  29.357                      }
  29.358                  }
  29.359              }
  29.360 @@ -575,18 +678,12 @@
  29.361                      infer.emptyContext, emptyDeferredAttrContext, types.noWarnings);
  29.362          }
  29.363  
  29.364 -        protected boolean validState(DeferredType dt) {
  29.365 -            return dt.mode != null &&
  29.366 -                    deferredAttrContext.mode.ordinal() <= dt.mode.ordinal();
  29.367 -        }
  29.368 -
  29.369          @Override
  29.370          public Type apply(Type t) {
  29.371              if (!t.hasTag(DEFERRED)) {
  29.372                  return t.map(this);
  29.373              } else {
  29.374                  DeferredType dt = (DeferredType)t;
  29.375 -                Assert.check(validState(dt));
  29.376                  return typeOf(dt);
  29.377              }
  29.378          }
  29.379 @@ -623,11 +720,6 @@
  29.380                          recover(dt) : owntype;
  29.381          }
  29.382  
  29.383 -        @Override
  29.384 -        protected boolean validState(DeferredType dt) {
  29.385 -            return true;
  29.386 -        }
  29.387 -
  29.388          /**
  29.389           * Synthesize a type for a deferred type that hasn't been previously
  29.390           * reduced to an ordinary type. Functional deferred types and conditionals
  29.391 @@ -647,25 +739,6 @@
  29.392      }
  29.393  
  29.394      /**
  29.395 -     * Retrieves the list of inference variables that need to be inferred before
  29.396 -     * an AST node can be type-checked
  29.397 -     */
  29.398 -    @SuppressWarnings("fallthrough")
  29.399 -    List<Type> stuckVars(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
  29.400 -                if (resultInfo.pt.hasTag(NONE) || resultInfo.pt.isErroneous()) {
  29.401 -            return List.nil();
  29.402 -        } else {
  29.403 -            return stuckVarsInternal(tree, resultInfo.pt, env, resultInfo.checkContext.inferenceContext());
  29.404 -        }
  29.405 -    }
  29.406 -    //where
  29.407 -        private List<Type> stuckVarsInternal(JCTree tree, Type pt, Env<AttrContext> env, Infer.InferenceContext inferenceContext) {
  29.408 -            StuckChecker sc = new StuckChecker(pt, env, inferenceContext);
  29.409 -            sc.scan(tree);
  29.410 -            return List.from(sc.stuckVars);
  29.411 -        }
  29.412 -
  29.413 -    /**
  29.414       * A special tree scanner that would only visit portions of a given tree.
  29.415       * The set of nodes visited by the scanner can be customized at construction-time.
  29.416       */
  29.417 @@ -737,17 +810,41 @@
  29.418       * inferring types that make some of the nested expressions incompatible
  29.419       * with their corresponding instantiated target
  29.420       */
  29.421 -    class StuckChecker extends PolyScanner {
  29.422 +    class CheckStuckPolicy extends PolyScanner implements DeferredStuckPolicy, Infer.FreeTypeListener {
  29.423  
  29.424          Type pt;
  29.425 -        Env<AttrContext> env;
  29.426          Infer.InferenceContext inferenceContext;
  29.427          Set<Type> stuckVars = new LinkedHashSet<Type>();
  29.428 +        Set<Type> depVars = new LinkedHashSet<Type>();
  29.429  
  29.430 -        StuckChecker(Type pt, Env<AttrContext> env, Infer.InferenceContext inferenceContext) {
  29.431 -            this.pt = pt;
  29.432 -            this.env = env;
  29.433 -            this.inferenceContext = inferenceContext;
  29.434 +        @Override
  29.435 +        public boolean isStuck() {
  29.436 +            return !stuckVars.isEmpty();
  29.437 +        }
  29.438 +
  29.439 +        @Override
  29.440 +        public Set<Type> stuckVars() {
  29.441 +            return stuckVars;
  29.442 +        }
  29.443 +
  29.444 +        @Override
  29.445 +        public Set<Type> depVars() {
  29.446 +            return depVars;
  29.447 +        }
  29.448 +
  29.449 +        public CheckStuckPolicy(ResultInfo resultInfo, DeferredType dt) {
  29.450 +            this.pt = resultInfo.pt;
  29.451 +            this.inferenceContext = resultInfo.checkContext.inferenceContext();
  29.452 +            scan(dt.tree);
  29.453 +            if (!stuckVars.isEmpty()) {
  29.454 +                resultInfo.checkContext.inferenceContext()
  29.455 +                        .addFreeTypeListener(List.from(stuckVars), this);
  29.456 +            }
  29.457 +        }
  29.458 +
  29.459 +        @Override
  29.460 +        public void typesInferred(InferenceContext inferenceContext) {
  29.461 +            stuckVars.clear();
  29.462          }
  29.463  
  29.464          @Override
  29.465 @@ -763,6 +860,7 @@
  29.466              if (tree.paramKind == JCLambda.ParameterKind.IMPLICIT &&
  29.467                      freeArgVars.nonEmpty()) {
  29.468                  stuckVars.addAll(freeArgVars);
  29.469 +                depVars.addAll(inferenceContext.freeVarsIn(descType.getReturnType()));
  29.470              }
  29.471              scanLambdaBody(tree, descType.getReturnType());
  29.472          }
  29.473 @@ -780,41 +878,34 @@
  29.474  
  29.475              Type descType = types.findDescriptorType(pt);
  29.476              List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
  29.477 -            Env<AttrContext> localEnv = env.dup(tree, env.info.dup());
  29.478 -            if (freeArgVars.nonEmpty()) {
  29.479 -                //perform arity-based check
  29.480 -                JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
  29.481 -                        attr.memberReferenceQualifierResult(tree));
  29.482 -                ListBuffer<Type> argtypes = ListBuffer.lb();
  29.483 -                for (Type t : descType.getParameterTypes()) {
  29.484 -                    argtypes.append(Type.noType);
  29.485 -                }
  29.486 -                JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
  29.487 -                mref2.expr = exprTree;
  29.488 -                Pair<Symbol, ReferenceLookupHelper> lookupRes =
  29.489 -                        rs.resolveMemberReference(tree, localEnv, mref2, exprTree.type,
  29.490 -                            tree.name, argtypes.toList(), null, true, rs.arityMethodCheck,
  29.491 -                            inferenceContext);
  29.492 -                Symbol res = tree.sym = lookupRes.fst;
  29.493 -                if (res.kind >= Kinds.ERRONEOUS ||
  29.494 -                        res.type.hasTag(FORALL) ||
  29.495 -                        (res.flags() & Flags.VARARGS) != 0 ||
  29.496 -                        (TreeInfo.isStaticSelector(exprTree, tree.name.table.names) &&
  29.497 -                        exprTree.type.isRaw())) {
  29.498 -                    stuckVars.addAll(freeArgVars);
  29.499 -                }
  29.500 +            if (freeArgVars.nonEmpty() &&
  29.501 +                    tree.overloadKind == JCMemberReference.OverloadKind.OVERLOADED) {
  29.502 +                stuckVars.addAll(freeArgVars);
  29.503 +                depVars.addAll(inferenceContext.freeVarsIn(descType.getReturnType()));
  29.504              }
  29.505          }
  29.506  
  29.507          void scanLambdaBody(JCLambda lambda, final Type pt) {
  29.508              if (lambda.getBodyKind() == JCTree.JCLambda.BodyKind.EXPRESSION) {
  29.509 -                stuckVars.addAll(stuckVarsInternal(lambda.body, pt, env, inferenceContext));
  29.510 +                Type prevPt = this.pt;
  29.511 +                try {
  29.512 +                    this.pt = pt;
  29.513 +                    scan(lambda.body);
  29.514 +                } finally {
  29.515 +                    this.pt = prevPt;
  29.516 +                }
  29.517              } else {
  29.518                  LambdaReturnScanner lambdaScanner = new LambdaReturnScanner() {
  29.519                      @Override
  29.520                      public void visitReturn(JCReturn tree) {
  29.521                          if (tree.expr != null) {
  29.522 -                            stuckVars.addAll(stuckVarsInternal(tree.expr, pt, env, inferenceContext));
  29.523 +                            Type prevPt = CheckStuckPolicy.this.pt;
  29.524 +                            try {
  29.525 +                                CheckStuckPolicy.this.pt = pt;
  29.526 +                                CheckStuckPolicy.this.scan(tree.expr);
  29.527 +                            } finally {
  29.528 +                                CheckStuckPolicy.this.pt = prevPt;
  29.529 +                            }
  29.530                          }
  29.531                      }
  29.532                  };
  29.533 @@ -824,6 +915,42 @@
  29.534      }
  29.535  
  29.536      /**
  29.537 +     * This visitor is used to check that structural expressions conform
  29.538 +     * to their target - this step is required as inference could end up
  29.539 +     * inferring types that make some of the nested expressions incompatible
  29.540 +     * with their corresponding instantiated target
  29.541 +     */
  29.542 +    class OverloadStuckPolicy extends CheckStuckPolicy implements DeferredStuckPolicy {
  29.543 +
  29.544 +        boolean stuck;
  29.545 +
  29.546 +        @Override
  29.547 +        public boolean isStuck() {
  29.548 +            return super.isStuck() || stuck;
  29.549 +        }
  29.550 +
  29.551 +        public OverloadStuckPolicy(ResultInfo resultInfo, DeferredType dt) {
  29.552 +            super(resultInfo, dt);
  29.553 +        }
  29.554 +
  29.555 +        @Override
  29.556 +        public void visitLambda(JCLambda tree) {
  29.557 +            super.visitLambda(tree);
  29.558 +            if (tree.paramKind == JCLambda.ParameterKind.IMPLICIT) {
  29.559 +                stuck = true;
  29.560 +            }
  29.561 +        }
  29.562 +
  29.563 +        @Override
  29.564 +        public void visitReference(JCMemberReference tree) {
  29.565 +            super.visitReference(tree);
  29.566 +            if (tree.overloadKind == JCMemberReference.OverloadKind.OVERLOADED) {
  29.567 +                stuck = true;
  29.568 +            }
  29.569 +        }
  29.570 +    }
  29.571 +
  29.572 +    /**
  29.573       * Does the argument expression {@code expr} need speculative type-checking?
  29.574       */
  29.575      boolean isDeferred(Env<AttrContext> env, JCExpression expr) {
  29.576 @@ -904,6 +1031,26 @@
  29.577  
  29.578          @Override
  29.579          public void visitReference(JCMemberReference tree) {
  29.580 +            //perform arity-based check
  29.581 +            Env<AttrContext> localEnv = env.dup(tree);
  29.582 +            JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
  29.583 +                    attr.memberReferenceQualifierResult(tree));
  29.584 +            JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
  29.585 +            mref2.expr = exprTree;
  29.586 +            Pair<Symbol, ReferenceLookupHelper> lookupRes =
  29.587 +                    rs.resolveMemberReference(tree, localEnv, mref2, exprTree.type,
  29.588 +                        tree.name, List.<Type>nil(), null, true, rs.nilMethodCheck,
  29.589 +                        infer.emptyContext);
  29.590 +            Symbol res = tree.sym = lookupRes.fst;
  29.591 +            if (res.kind >= Kinds.ERRONEOUS ||
  29.592 +                    res.type.hasTag(FORALL) ||
  29.593 +                    (res.flags() & Flags.VARARGS) != 0 ||
  29.594 +                    (TreeInfo.isStaticSelector(exprTree, tree.name.table.names) &&
  29.595 +                    exprTree.type.isRaw())) {
  29.596 +                tree.overloadKind = JCMemberReference.OverloadKind.OVERLOADED;
  29.597 +            } else {
  29.598 +                tree.overloadKind = JCMemberReference.OverloadKind.UNOVERLOADED;
  29.599 +            }
  29.600              //a method reference is always a poly expression
  29.601              result = ArgumentExpressionKind.POLY;
  29.602          }

    30.1 --- a/src/share/classes/com/sun/tools/javac/comp/Flow.java	Thu Sep 12 11:09:20 2013 -0700
    30.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Flow.java	Tue Sep 17 08:21:11 2013 -0700
    30.3 @@ -207,7 +207,7 @@
    30.4  
    30.5      public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
    30.6          new AliveAnalyzer().analyzeTree(env, make);
    30.7 -        new AssignAnalyzer().analyzeTree(env, make);
    30.8 +        new AssignAnalyzer(log, syms, lint, names).analyzeTree(env);
    30.9          new FlowAnalyzer().analyzeTree(env, make);
   30.10          new CaptureAnalyzer().analyzeTree(env, make);
   30.11      }
   30.12 @@ -224,7 +224,6 @@
   30.13          }
   30.14          try {
   30.15              new AliveAnalyzer().analyzeTree(env, that, make);
   30.16 -            new LambdaFlowAnalyzer().analyzeTree(env, that, make);
   30.17          } finally {
   30.18              if (!speculative) {
   30.19                  log.popDiagnosticHandler(diagHandler);
   30.20 @@ -232,6 +231,23 @@
   30.21          }
   30.22      }
   30.23  
   30.24 +    public List<Type> analyzeLambdaThrownTypes(Env<AttrContext> env, JCLambda that, TreeMaker make) {
   30.25 +        //we need to disable diagnostics temporarily; the problem is that if
   30.26 +        //a lambda expression contains e.g. an unreachable statement, an error
   30.27 +        //message will be reported and will cause compilation to skip the flow analyis
   30.28 +        //step - if we suppress diagnostics, we won't stop at Attr for flow-analysis
   30.29 +        //related errors, which will allow for more errors to be detected
   30.30 +        Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
   30.31 +        try {
   30.32 +            new AssignAnalyzer(log, syms, lint, names).analyzeTree(env);
   30.33 +            LambdaFlowAnalyzer flowAnalyzer = new LambdaFlowAnalyzer();
   30.34 +            flowAnalyzer.analyzeTree(env, that, make);
   30.35 +            return flowAnalyzer.inferredThrownTypes;
   30.36 +        } finally {
   30.37 +            log.popDiagnosticHandler(diagHandler);
   30.38 +        }
   30.39 +    }
   30.40 +
   30.41      /**
   30.42       * Definite assignment scan mode
   30.43       */
   30.44 @@ -276,15 +292,6 @@
   30.45      }
   30.46  
   30.47      /**
   30.48 -     * Utility method to reset several Bits instances.
   30.49 -     */
   30.50 -    private void resetBits(Bits... bits) {
   30.51 -        for (Bits b : bits) {
   30.52 -            b.reset();
   30.53 -        }
   30.54 -    }
   30.55 -
   30.56 -    /**
   30.57       * Base visitor class for all visitors implementing dataflow analysis logic.
   30.58       * This class define the shared logic for handling jumps (break/continue statements).
   30.59       */
   30.60 @@ -331,17 +338,17 @@
   30.61                  this.tree = tree;
   30.62              }
   30.63  
   30.64 -            void resolveJump() {
   30.65 +            void resolveJump(JCTree tree) {
   30.66                  //do nothing
   30.67              }
   30.68          }
   30.69  
   30.70 -        abstract void markDead();
   30.71 +        abstract void markDead(JCTree tree);
   30.72  
   30.73          /** Record an outward transfer of control. */
   30.74          void recordExit(JCTree tree, P pe) {
   30.75              pendingExits.append(pe);
   30.76 -            markDead();
   30.77 +            markDead(tree);
   30.78          }
   30.79  
   30.80          /** Resolve all jumps of this statement. */
   30.81 @@ -355,7 +362,7 @@
   30.82                  P exit = exits.head;
   30.83                  if (exit.tree.hasTag(jk.treeTag) &&
   30.84                          jk.getTarget(exit.tree) == tree) {
   30.85 -                    exit.resolveJump();
   30.86 +                    exit.resolveJump(tree);
   30.87                      resolved = true;
   30.88                  } else {
   30.89                      pendingExits.append(exit);
   30.90 @@ -364,12 +371,12 @@
   30.91              return resolved;
   30.92          }
   30.93  
   30.94 -        /** Resolve all breaks of this statement. */
   30.95 +        /** Resolve all continues of this statement. */
   30.96          boolean resolveContinues(JCTree tree) {
   30.97              return resolveJump(tree, new ListBuffer<P>(), JumpKind.CONTINUE);
   30.98          }
   30.99  
  30.100 -        /** Resolve all continues of this statement. */
  30.101 +        /** Resolve all breaks of this statement. */
  30.102          boolean resolveBreaks(JCTree tree, ListBuffer<P> oldPendingExits) {
  30.103              return resolveJump(tree, oldPendingExits, JumpKind.BREAK);
  30.104          }
  30.105 @@ -398,7 +405,7 @@
  30.106          private boolean alive;
  30.107  
  30.108          @Override
  30.109 -        void markDead() {
  30.110 +        void markDead(JCTree tree) {
  30.111              alive = false;
  30.112          }
  30.113  
  30.114 @@ -680,7 +687,7 @@
  30.115  
  30.116          public void visitThrow(JCThrow tree) {
  30.117              scan(tree.expr);
  30.118 -            markDead();
  30.119 +            markDead(tree);
  30.120          }
  30.121  
  30.122          public void visitApply(JCMethodInvocation tree) {
  30.123 @@ -781,7 +788,7 @@
  30.124          }
  30.125  
  30.126          @Override
  30.127 -        void markDead() {
  30.128 +        void markDead(JCTree tree) {
  30.129              //do nothing
  30.130          }
  30.131  
  30.132 @@ -1206,7 +1213,7 @@
  30.133              else {
  30.134                  markThrown(tree, tree.expr.type);
  30.135              }
  30.136 -            markDead();
  30.137 +            markDead(tree);
  30.138          }
  30.139  
  30.140          public void visitApply(JCMethodInvocation tree) {
  30.141 @@ -1318,27 +1325,35 @@
  30.142       * Specialized pass that performs inference of thrown types for lambdas.
  30.143       */
  30.144      class LambdaFlowAnalyzer extends FlowAnalyzer {
  30.145 +        List<Type> inferredThrownTypes;
  30.146 +        boolean inLambda;
  30.147          @Override
  30.148          public void visitLambda(JCLambda tree) {
  30.149 -            if (tree.type != null &&
  30.150 -                    tree.type.isErroneous()) {
  30.151 +            if ((tree.type != null &&
  30.152 +                    tree.type.isErroneous()) || inLambda) {
  30.153                  return;
  30.154              }
  30.155              List<Type> prevCaught = caught;
  30.156              List<Type> prevThrown = thrown;
  30.157              ListBuffer<FlowPendingExit> prevPending = pendingExits;
  30.158 +            inLambda = true;
  30.159              try {
  30.160                  pendingExits = ListBuffer.lb();
  30.161                  caught = List.of(syms.throwableType);
  30.162                  thrown = List.nil();
  30.163                  scan(tree.body);
  30.164 -                tree.inferredThrownTypes = thrown;
  30.165 +                inferredThrownTypes = thrown;
  30.166              } finally {
  30.167                  pendingExits = prevPending;
  30.168                  caught = prevCaught;
  30.169                  thrown = prevThrown;
  30.170 +                inLambda = false;
  30.171              }
  30.172          }
  30.173 +        @Override
  30.174 +        public void visitClassDef(JCClassDecl tree) {
  30.175 +            //skip
  30.176 +        }
  30.177      }
  30.178  
  30.179      /**
  30.180 @@ -1348,11 +1363,13 @@
  30.181       * depends on the results of the liveliness analyzer. This pass is also used to mark
  30.182       * effectively-final local variables/parameters.
  30.183       */
  30.184 -    class AssignAnalyzer extends BaseAnalyzer<AssignAnalyzer.AssignPendingExit> {
  30.185 +
  30.186 +    public abstract static class AbstractAssignAnalyzer<P extends AbstractAssignAnalyzer.AbstractAssignPendingExit>
  30.187 +        extends BaseAnalyzer<P> {
  30.188  
  30.189          /** The set of definitely assigned variables.
  30.190           */
  30.191 -        final Bits inits;
  30.192 +        protected final Bits inits;
  30.193  
  30.194          /** The set of definitely unassigned variables.
  30.195           */
  30.196 @@ -1378,7 +1395,7 @@
  30.197  
  30.198          /** A mapping from addresses to variable symbols.
  30.199           */
  30.200 -        JCVariableDecl[] vardecls;
  30.201 +        protected JCVariableDecl[] vardecls;
  30.202  
  30.203          /** The current class being defined.
  30.204           */
  30.205 @@ -1390,11 +1407,11 @@
  30.206  
  30.207          /** The next available variable sequence number.
  30.208           */
  30.209 -        int nextadr;
  30.210 +        protected int nextadr;
  30.211  
  30.212          /** The first variable sequence number in a block that can return.
  30.213           */
  30.214 -        int returnadr;
  30.215 +        protected int returnadr;
  30.216  
  30.217          /** The list of unreferenced automatic resources.
  30.218           */
  30.219 @@ -1406,35 +1423,46 @@
  30.220          /** The starting position of the analysed tree */
  30.221          int startPos;
  30.222  
  30.223 -        AssignAnalyzer() {
  30.224 -            inits = new Bits();
  30.225 +        final Symtab syms;
  30.226 +
  30.227 +        protected Names names;
  30.228 +
  30.229 +        public static class AbstractAssignPendingExit extends BaseAnalyzer.PendingExit {
  30.230 +
  30.231 +            final Bits inits;
  30.232 +            final Bits uninits;
  30.233 +            final Bits exit_inits = new Bits(true);
  30.234 +            final Bits exit_uninits = new Bits(true);
  30.235 +
  30.236 +            public AbstractAssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
  30.237 +                super(tree);
  30.238 +                this.inits = inits;
  30.239 +                this.uninits = uninits;
  30.240 +                this.exit_inits.assign(inits);
  30.241 +                this.exit_uninits.assign(uninits);
  30.242 +            }
  30.243 +
  30.244 +            @Override
  30.245 +            public void resolveJump(JCTree tree) {
  30.246 +                inits.andSet(exit_inits);
  30.247 +                uninits.andSet(exit_uninits);
  30.248 +            }
  30.249 +        }
  30.250 +
  30.251 +        public AbstractAssignAnalyzer(Bits inits, Symtab syms, Names names) {
  30.252 +            this.inits = inits;
  30.253              uninits = new Bits();
  30.254              uninitsTry = new Bits();
  30.255              initsWhenTrue = new Bits(true);
  30.256              initsWhenFalse = new Bits(true);
  30.257              uninitsWhenTrue = new Bits(true);
  30.258              uninitsWhenFalse = new Bits(true);
  30.259 -        }
  30.260 -
  30.261 -        class AssignPendingExit extends BaseAnalyzer.PendingExit {
  30.262 -
  30.263 -            final Bits exit_inits = new Bits(true);
  30.264 -            final Bits exit_uninits = new Bits(true);
  30.265 -
  30.266 -            AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
  30.267 -                super(tree);
  30.268 -                this.exit_inits.assign(inits);
  30.269 -                this.exit_uninits.assign(uninits);
  30.270 -            }
  30.271 -
  30.272 -            void resolveJump() {
  30.273 -                inits.andSet(exit_inits);
  30.274 -                uninits.andSet(exit_uninits);
  30.275 -            }
  30.276 +            this.syms = syms;
  30.277 +            this.names = names;
  30.278          }
  30.279  
  30.280          @Override
  30.281 -        void markDead() {
  30.282 +        protected void markDead(JCTree tree) {
  30.283              inits.inclRange(returnadr, nextadr);
  30.284              uninits.inclRange(returnadr, nextadr);
  30.285          }
  30.286 @@ -1444,7 +1472,7 @@
  30.287          /** Do we need to track init/uninit state of this symbol?
  30.288           *  I.e. is symbol either a local or a blank final variable?
  30.289           */
  30.290 -        boolean trackable(VarSymbol sym) {
  30.291 +        protected boolean trackable(VarSymbol sym) {
  30.292              return
  30.293                  sym.pos >= startPos &&
  30.294                  ((sym.owner.kind == MTH ||
  30.295 @@ -1464,44 +1492,35 @@
  30.296              }
  30.297              sym.adr = nextadr;
  30.298              vardecls[nextadr] = varDecl;
  30.299 -            inits.excl(nextadr);
  30.300 +            exclVarFromInits(varDecl, nextadr);
  30.301              uninits.incl(nextadr);
  30.302              nextadr++;
  30.303          }
  30.304  
  30.305 +        protected void exclVarFromInits(JCTree tree, int adr) {
  30.306 +            inits.excl(adr);
  30.307 +        }
  30.308 +
  30.309 +        protected void assignToInits(JCTree tree, Bits bits) {
  30.310 +            inits.assign(bits);
  30.311 +        }
  30.312 +
  30.313 +        protected void andSetInits(JCTree tree, Bits bits) {
  30.314 +            inits.andSet(bits);
  30.315 +        }
  30.316 +
  30.317 +        protected void orSetInits(JCTree tree, Bits bits) {
  30.318 +            inits.orSet(bits);
  30.319 +        }
  30.320 +
  30.321          /** Record an initialization of a trackable variable.
  30.322           */
  30.323          void letInit(DiagnosticPosition pos, VarSymbol sym) {
  30.324              if (sym.adr >= firstadr && trackable(sym)) {
  30.325 -                if ((sym.flags() & EFFECTIVELY_FINAL) != 0) {
  30.326 -                    if (!uninits.isMember(sym.adr)) {
  30.327 -                        //assignment targeting an effectively final variable
  30.328 -                        //makes the variable lose its status of effectively final
  30.329 -                        //if the variable is _not_ definitively unassigned
  30.330 -                        sym.flags_field &= ~EFFECTIVELY_FINAL;
  30.331 -                    } else {
  30.332 -                        uninit(sym);
  30.333 -                    }
  30.334 -                }
  30.335 -                else if ((sym.flags() & FINAL) != 0) {
  30.336 -                    if ((sym.flags() & PARAMETER) != 0) {
  30.337 -                        if ((sym.flags() & UNION) != 0) { //multi-catch parameter
  30.338 -                            log.error(pos, "multicatch.parameter.may.not.be.assigned",
  30.339 -                                      sym);
  30.340 -                        }
  30.341 -                        else {
  30.342 -                            log.error(pos, "final.parameter.may.not.be.assigned",
  30.343 -                                  sym);
  30.344 -                        }
  30.345 -                    } else if (!uninits.isMember(sym.adr)) {
  30.346 -                        log.error(pos, flowKind.errKey, sym);
  30.347 -                    } else {
  30.348 -                        uninit(sym);
  30.349 -                    }
  30.350 +                if (uninits.isMember(sym.adr)) {
  30.351 +                    uninit(sym);
  30.352                  }
  30.353                  inits.incl(sym.adr);
  30.354 -            } else if ((sym.flags() & FINAL) != 0) {
  30.355 -                log.error(pos, "var.might.already.be.assigned", sym);
  30.356              }
  30.357          }
  30.358          //where
  30.359 @@ -1535,12 +1554,14 @@
  30.360          void checkInit(DiagnosticPosition pos, VarSymbol sym) {
  30.361              checkInit(pos, sym, "var.might.not.have.been.initialized");
  30.362          }
  30.363 -        void checkInit(DiagnosticPosition pos, VarSymbol sym, String errkey) {
  30.364 -            if ((sym.adr >= firstadr || sym.owner.kind != TYP) &&
  30.365 -                trackable(sym) &&
  30.366 -                !inits.isMember(sym.adr)) {
  30.367 -                log.error(pos, errkey, sym);
  30.368 -                inits.incl(sym.adr);
  30.369 +
  30.370 +        void checkInit(DiagnosticPosition pos, VarSymbol sym, String errkey) {}
  30.371 +
  30.372 +        /** Utility method to reset several Bits instances.
  30.373 +         */
  30.374 +        private void resetBits(Bits... bits) {
  30.375 +            for (Bits b : bits) {
  30.376 +                b.reset();
  30.377              }
  30.378          }
  30.379  
  30.380 @@ -1558,7 +1579,7 @@
  30.381  
  30.382          /** Merge (intersect) inits/uninits from WhenTrue/WhenFalse sets.
  30.383           */
  30.384 -        void merge() {
  30.385 +        protected void merge(JCTree tree) {
  30.386              inits.assign(initsWhenFalse.andSet(initsWhenTrue));
  30.387              uninits.assign(uninitsWhenFalse.andSet(uninitsWhenTrue));
  30.388          }
  30.389 @@ -1573,7 +1594,9 @@
  30.390          void scanExpr(JCTree tree) {
  30.391              if (tree != null) {
  30.392                  scan(tree);
  30.393 -                if (inits.isReset()) merge();
  30.394 +                if (inits.isReset()) {
  30.395 +                    merge(tree);
  30.396 +                }
  30.397              }
  30.398          }
  30.399  
  30.400 @@ -1590,7 +1613,7 @@
  30.401           */
  30.402          void scanCond(JCTree tree) {
  30.403              if (tree.type.isFalse()) {
  30.404 -                if (inits.isReset()) merge();
  30.405 +                if (inits.isReset()) merge(tree);
  30.406                  initsWhenTrue.assign(inits);
  30.407                  initsWhenTrue.inclRange(firstadr, nextadr);
  30.408                  uninitsWhenTrue.assign(uninits);
  30.409 @@ -1598,7 +1621,7 @@
  30.410                  initsWhenFalse.assign(inits);
  30.411                  uninitsWhenFalse.assign(uninits);
  30.412              } else if (tree.type.isTrue()) {
  30.413 -                if (inits.isReset()) merge();
  30.414 +                if (inits.isReset()) merge(tree);
  30.415                  initsWhenFalse.assign(inits);
  30.416                  initsWhenFalse.inclRange(firstadr, nextadr);
  30.417                  uninitsWhenFalse.assign(uninits);
  30.418 @@ -1617,22 +1640,22 @@
  30.419  
  30.420          /* ------------ Visitor methods for various sorts of trees -------------*/
  30.421  
  30.422 +        @Override
  30.423          public void visitClassDef(JCClassDecl tree) {
  30.424 -            if (tree.sym == null) return;
  30.425 +            if (tree.sym == null) {
  30.426 +                return;
  30.427 +            }
  30.428  
  30.429              JCClassDecl classDefPrev = classDef;
  30.430              int firstadrPrev = firstadr;
  30.431              int nextadrPrev = nextadr;
  30.432 -            ListBuffer<AssignPendingExit> pendingExitsPrev = pendingExits;
  30.433 -            Lint lintPrev = lint;
  30.434 +            ListBuffer<P> pendingExitsPrev = pendingExits;
  30.435  
  30.436 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.437 +            pendingExits = new ListBuffer<P>();
  30.438              if (tree.name != names.empty) {
  30.439                  firstadr = nextadr;
  30.440              }
  30.441              classDef = tree;
  30.442 -            lint = lint.augment(tree.sym);
  30.443 -
  30.444              try {
  30.445                  // define all the static fields
  30.446                  for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
  30.447 @@ -1640,8 +1663,9 @@
  30.448                          JCVariableDecl def = (JCVariableDecl)l.head;
  30.449                          if ((def.mods.flags & STATIC) != 0) {
  30.450                              VarSymbol sym = def.sym;
  30.451 -                            if (trackable(sym))
  30.452 +                            if (trackable(sym)) {
  30.453                                  newVar(def);
  30.454 +                            }
  30.455                          }
  30.456                      }
  30.457                  }
  30.458 @@ -1660,8 +1684,9 @@
  30.459                          JCVariableDecl def = (JCVariableDecl)l.head;
  30.460                          if ((def.mods.flags & STATIC) == 0) {
  30.461                              VarSymbol sym = def.sym;
  30.462 -                            if (trackable(sym))
  30.463 +                            if (trackable(sym)) {
  30.464                                  newVar(def);
  30.465 +                            }
  30.466                          }
  30.467                      }
  30.468                  }
  30.469 @@ -1685,21 +1710,25 @@
  30.470                  nextadr = nextadrPrev;
  30.471                  firstadr = firstadrPrev;
  30.472                  classDef = classDefPrev;
  30.473 -                lint = lintPrev;
  30.474              }
  30.475          }
  30.476  
  30.477 +        @Override
  30.478          public void visitMethodDef(JCMethodDecl tree) {
  30.479 -            if (tree.body == null) return;
  30.480 +            if (tree.body == null) {
  30.481 +                return;
  30.482 +            }
  30.483 +            /*  MemberEnter can generate synthetic methods, ignore them
  30.484 +             */
  30.485 +            if ((tree.sym.flags() & SYNTHETIC) != 0) {
  30.486 +                return;
  30.487 +            }
  30.488  
  30.489              final Bits initsPrev = new Bits(inits);
  30.490              final Bits uninitsPrev = new Bits(uninits);
  30.491              int nextadrPrev = nextadr;
  30.492              int firstadrPrev = firstadr;
  30.493              int returnadrPrev = returnadr;
  30.494 -            Lint lintPrev = lint;
  30.495 -
  30.496 -            lint = lint.augment(tree.sym);
  30.497  
  30.498              Assert.check(pendingExits.isEmpty());
  30.499  
  30.500 @@ -1707,13 +1736,17 @@
  30.501                  boolean isInitialConstructor =
  30.502                      TreeInfo.isInitialConstructor(tree);
  30.503  
  30.504 -                if (!isInitialConstructor)
  30.505 +                if (!isInitialConstructor) {
  30.506                      firstadr = nextadr;
  30.507 +                }
  30.508                  for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
  30.509                      JCVariableDecl def = l.head;
  30.510                      scan(def);
  30.511 -                    inits.incl(def.sym.adr);
  30.512 -                    uninits.excl(def.sym.adr);
  30.513 +                    Assert.check((def.sym.flags() & PARAMETER) != 0, "Method parameter without PARAMETER flag");
  30.514 +                    /*  If we are executing the code from Gen, then there can be
  30.515 +                     *  synthetic or mandated variables, ignore them.
  30.516 +                     */
  30.517 +                    initParam(def);
  30.518                  }
  30.519                  // else we are in an instance initializer block;
  30.520                  // leave caught unchanged.
  30.521 @@ -1737,39 +1770,42 @@
  30.522                          }
  30.523                      }
  30.524                  }
  30.525 -                List<AssignPendingExit> exits = pendingExits.toList();
  30.526 -                pendingExits = new ListBuffer<AssignPendingExit>();
  30.527 +                List<P> exits = pendingExits.toList();
  30.528 +                pendingExits = new ListBuffer<>();
  30.529                  while (exits.nonEmpty()) {
  30.530 -                    AssignPendingExit exit = exits.head;
  30.531 +                    P exit = exits.head;
  30.532                      exits = exits.tail;
  30.533                      Assert.check(exit.tree.hasTag(RETURN), exit.tree);
  30.534                      if (isInitialConstructor) {
  30.535 -                        inits.assign(exit.exit_inits);
  30.536 -                        for (int i = firstadr; i < nextadr; i++)
  30.537 +                        assignToInits(exit.tree, exit.exit_inits);
  30.538 +                        for (int i = firstadr; i < nextadr; i++) {
  30.539                              checkInit(exit.tree.pos(), vardecls[i].sym);
  30.540 +                        }
  30.541                      }
  30.542                  }
  30.543              } finally {
  30.544 -                inits.assign(initsPrev);
  30.545 +                assignToInits(tree, initsPrev);
  30.546                  uninits.assign(uninitsPrev);
  30.547                  nextadr = nextadrPrev;
  30.548                  firstadr = firstadrPrev;
  30.549                  returnadr = returnadrPrev;
  30.550 -                lint = lintPrev;
  30.551              }
  30.552          }
  30.553  
  30.554 +        protected void initParam(JCVariableDecl def) {
  30.555 +            inits.incl(def.sym.adr);
  30.556 +            uninits.excl(def.sym.adr);
  30.557 +        }
  30.558 +
  30.559          public void visitVarDef(JCVariableDecl tree) {
  30.560              boolean track = trackable(tree.sym);
  30.561 -            if (track && tree.sym.owner.kind == MTH) newVar(tree);
  30.562 +            if (track && tree.sym.owner.kind == MTH) {
  30.563 +                newVar(tree);
  30.564 +            }
  30.565              if (tree.init != null) {
  30.566 -                Lint lintPrev = lint;
  30.567 -                lint = lint.augment(tree.sym);
  30.568 -                try{
  30.569 -                    scanExpr(tree.init);
  30.570 -                    if (track) letInit(tree.pos(), tree.sym);
  30.571 -                } finally {
  30.572 -                    lint = lintPrev;
  30.573 +                scanExpr(tree.init);
  30.574 +                if (track) {
  30.575 +                    letInit(tree.pos(), tree.sym);
  30.576                  }
  30.577              }
  30.578          }
  30.579 @@ -1780,14 +1816,18 @@
  30.580              nextadr = nextadrPrev;
  30.581          }
  30.582  
  30.583 +        int getLogNumberOfErrors() {
  30.584 +            return 0;
  30.585 +        }
  30.586 +
  30.587          public void visitDoLoop(JCDoWhileLoop tree) {
  30.588 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.589 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.590              FlowKind prevFlowKind = flowKind;
  30.591              flowKind = FlowKind.NORMAL;
  30.592              final Bits initsSkip = new Bits(true);
  30.593              final Bits uninitsSkip = new Bits(true);
  30.594 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.595 -            int prevErrors = log.nerrors;
  30.596 +            pendingExits = new ListBuffer<P>();
  30.597 +            int prevErrors = getLogNumberOfErrors();
  30.598              do {
  30.599                  final Bits uninitsEntry = new Bits(uninits);
  30.600                  uninitsEntry.excludeFrom(nextadr);
  30.601 @@ -1798,28 +1838,28 @@
  30.602                      initsSkip.assign(initsWhenFalse);
  30.603                      uninitsSkip.assign(uninitsWhenFalse);
  30.604                  }
  30.605 -                if (log.nerrors !=  prevErrors ||
  30.606 +                if (getLogNumberOfErrors() !=  prevErrors ||
  30.607                      flowKind.isFinal() ||
  30.608                      new Bits(uninitsEntry).diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
  30.609                      break;
  30.610 -                inits.assign(initsWhenTrue);
  30.611 +                assignToInits(tree.cond, initsWhenTrue);
  30.612                  uninits.assign(uninitsEntry.andSet(uninitsWhenTrue));
  30.613                  flowKind = FlowKind.SPECULATIVE_LOOP;
  30.614              } while (true);
  30.615              flowKind = prevFlowKind;
  30.616 -            inits.assign(initsSkip);
  30.617 +            assignToInits(tree, initsSkip);
  30.618              uninits.assign(uninitsSkip);
  30.619              resolveBreaks(tree, prevPendingExits);
  30.620          }
  30.621  
  30.622          public void visitWhileLoop(JCWhileLoop tree) {
  30.623 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.624 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.625              FlowKind prevFlowKind = flowKind;
  30.626              flowKind = FlowKind.NORMAL;
  30.627              final Bits initsSkip = new Bits(true);
  30.628              final Bits uninitsSkip = new Bits(true);
  30.629 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.630 -            int prevErrors = log.nerrors;
  30.631 +            pendingExits = new ListBuffer<>();
  30.632 +            int prevErrors = getLogNumberOfErrors();
  30.633              final Bits uninitsEntry = new Bits(uninits);
  30.634              uninitsEntry.excludeFrom(nextadr);
  30.635              do {
  30.636 @@ -1828,35 +1868,36 @@
  30.637                      initsSkip.assign(initsWhenFalse) ;
  30.638                      uninitsSkip.assign(uninitsWhenFalse);
  30.639                  }
  30.640 -                inits.assign(initsWhenTrue);
  30.641 +                assignToInits(tree, initsWhenTrue);
  30.642                  uninits.assign(uninitsWhenTrue);
  30.643                  scan(tree.body);
  30.644                  resolveContinues(tree);
  30.645 -                if (log.nerrors != prevErrors ||
  30.646 +                if (getLogNumberOfErrors() != prevErrors ||
  30.647                      flowKind.isFinal() ||
  30.648 -                    new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
  30.649 +                    new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1) {
  30.650                      break;
  30.651 +                }
  30.652                  uninits.assign(uninitsEntry.andSet(uninits));
  30.653                  flowKind = FlowKind.SPECULATIVE_LOOP;
  30.654              } while (true);
  30.655              flowKind = prevFlowKind;
  30.656              //a variable is DA/DU after the while statement, if it's DA/DU assuming the
  30.657              //branch is not taken AND if it's DA/DU before any break statement
  30.658 -            inits.assign(initsSkip);
  30.659 +            assignToInits(tree.body, initsSkip);
  30.660              uninits.assign(uninitsSkip);
  30.661              resolveBreaks(tree, prevPendingExits);
  30.662          }
  30.663  
  30.664          public void visitForLoop(JCForLoop tree) {
  30.665 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.666 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.667              FlowKind prevFlowKind = flowKind;
  30.668              flowKind = FlowKind.NORMAL;
  30.669              int nextadrPrev = nextadr;
  30.670              scan(tree.init);
  30.671              final Bits initsSkip = new Bits(true);
  30.672              final Bits uninitsSkip = new Bits(true);
  30.673 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.674 -            int prevErrors = log.nerrors;
  30.675 +            pendingExits = new ListBuffer<P>();
  30.676 +            int prevErrors = getLogNumberOfErrors();
  30.677              do {
  30.678                  final Bits uninitsEntry = new Bits(uninits);
  30.679                  uninitsEntry.excludeFrom(nextadr);
  30.680 @@ -1866,7 +1907,7 @@
  30.681                          initsSkip.assign(initsWhenFalse);
  30.682                          uninitsSkip.assign(uninitsWhenFalse);
  30.683                      }
  30.684 -                    inits.assign(initsWhenTrue);
  30.685 +                    assignToInits(tree.body, initsWhenTrue);
  30.686                      uninits.assign(uninitsWhenTrue);
  30.687                  } else if (!flowKind.isFinal()) {
  30.688                      initsSkip.assign(inits);
  30.689 @@ -1877,7 +1918,7 @@
  30.690                  scan(tree.body);
  30.691                  resolveContinues(tree);
  30.692                  scan(tree.step);
  30.693 -                if (log.nerrors != prevErrors ||
  30.694 +                if (getLogNumberOfErrors() != prevErrors ||
  30.695                      flowKind.isFinal() ||
  30.696                      new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
  30.697                      break;
  30.698 @@ -1887,7 +1928,7 @@
  30.699              flowKind = prevFlowKind;
  30.700              //a variable is DA/DU after a for loop, if it's DA/DU assuming the
  30.701              //branch is not taken AND if it's DA/DU before any break statement
  30.702 -            inits.assign(initsSkip);
  30.703 +            assignToInits(tree.body, initsSkip);
  30.704              uninits.assign(uninitsSkip);
  30.705              resolveBreaks(tree, prevPendingExits);
  30.706              nextadr = nextadrPrev;
  30.707 @@ -1896,7 +1937,7 @@
  30.708          public void visitForeachLoop(JCEnhancedForLoop tree) {
  30.709              visitVarDef(tree.var);
  30.710  
  30.711 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.712 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.713              FlowKind prevFlowKind = flowKind;
  30.714              flowKind = FlowKind.NORMAL;
  30.715              int nextadrPrev = nextadr;
  30.716 @@ -1905,14 +1946,14 @@
  30.717              final Bits uninitsStart = new Bits(uninits);
  30.718  
  30.719              letInit(tree.pos(), tree.var.sym);
  30.720 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.721 -            int prevErrors = log.nerrors;
  30.722 +            pendingExits = new ListBuffer<P>();
  30.723 +            int prevErrors = getLogNumberOfErrors();
  30.724              do {
  30.725                  final Bits uninitsEntry = new Bits(uninits);
  30.726                  uninitsEntry.excludeFrom(nextadr);
  30.727                  scan(tree.body);
  30.728                  resolveContinues(tree);
  30.729 -                if (log.nerrors != prevErrors ||
  30.730 +                if (getLogNumberOfErrors() != prevErrors ||
  30.731                      flowKind.isFinal() ||
  30.732                      new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
  30.733                      break;
  30.734 @@ -1920,41 +1961,50 @@
  30.735                  flowKind = FlowKind.SPECULATIVE_LOOP;
  30.736              } while (true);
  30.737              flowKind = prevFlowKind;
  30.738 -            inits.assign(initsStart);
  30.739 +            assignToInits(tree.body, initsStart);
  30.740              uninits.assign(uninitsStart.andSet(uninits));
  30.741              resolveBreaks(tree, prevPendingExits);
  30.742              nextadr = nextadrPrev;
  30.743          }
  30.744  
  30.745          public void visitLabelled(JCLabeledStatement tree) {
  30.746 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.747 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.748 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.749 +            pendingExits = new ListBuffer<P>();
  30.750              scan(tree.body);
  30.751              resolveBreaks(tree, prevPendingExits);
  30.752          }
  30.753  
  30.754          public void visitSwitch(JCSwitch tree) {
  30.755 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.756 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.757 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.758 +            pendingExits = new ListBuffer<>();
  30.759              int nextadrPrev = nextadr;
  30.760              scanExpr(tree.selector);
  30.761              final Bits initsSwitch = new Bits(inits);
  30.762              final Bits uninitsSwitch = new Bits(uninits);
  30.763              boolean hasDefault = false;
  30.764              for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
  30.765 -                inits.assign(initsSwitch);
  30.766 +                assignToInits(l.head, initsSwitch);
  30.767                  uninits.assign(uninits.andSet(uninitsSwitch));
  30.768                  JCCase c = l.head;
  30.769 -                if (c.pat == null)
  30.770 +                if (c.pat == null) {
  30.771                      hasDefault = true;
  30.772 -                else
  30.773 +                } else {
  30.774                      scanExpr(c.pat);
  30.775 +                }
  30.776 +                if (hasDefault) {
  30.777 +                    assignToInits(null, initsSwitch);
  30.778 +                    uninits.assign(uninits.andSet(uninitsSwitch));
  30.779 +                }
  30.780                  scan(c.stats);
  30.781                  addVars(c.stats, initsSwitch, uninitsSwitch);
  30.782 +                if (!hasDefault) {
  30.783 +                    assignToInits(l.head.stats.last(), initsSwitch);
  30.784 +                    uninits.assign(uninits.andSet(uninitsSwitch));
  30.785 +                }
  30.786                  // Warn about fall-through if lint switch fallthrough enabled.
  30.787              }
  30.788              if (!hasDefault) {
  30.789 -                inits.andSet(initsSwitch);
  30.790 +                andSetInits(null, initsSwitch);
  30.791              }
  30.792              resolveBreaks(tree, prevPendingExits);
  30.793              nextadr = nextadrPrev;
  30.794 @@ -1973,11 +2023,17 @@
  30.795                  }
  30.796              }
  30.797  
  30.798 +        boolean isEnabled(Lint.LintCategory lc) {
  30.799 +            return false;
  30.800 +        }
  30.801 +
  30.802 +        void reportWarning(Lint.LintCategory lc, DiagnosticPosition pos, String key, Object ... args) {}
  30.803 +
  30.804          public void visitTry(JCTry tree) {
  30.805              ListBuffer<JCVariableDecl> resourceVarDecls = ListBuffer.lb();
  30.806              final Bits uninitsTryPrev = new Bits(uninitsTry);
  30.807 -            ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
  30.808 -            pendingExits = new ListBuffer<AssignPendingExit>();
  30.809 +            ListBuffer<P> prevPendingExits = pendingExits;
  30.810 +            pendingExits = new ListBuffer<>();
  30.811              final Bits initsTry = new Bits(inits);
  30.812              uninitsTry.assign(uninits);
  30.813              for (JCTree resource : tree.resources) {
  30.814 @@ -1999,10 +2055,10 @@
  30.815              int nextadrCatch = nextadr;
  30.816  
  30.817              if (!resourceVarDecls.isEmpty() &&
  30.818 -                    lint.isEnabled(Lint.LintCategory.TRY)) {
  30.819 +                    isEnabled(Lint.LintCategory.TRY)) {
  30.820                  for (JCVariableDecl resVar : resourceVarDecls) {
  30.821                      if (unrefdResources.includes(resVar.sym)) {
  30.822 -                        log.warning(Lint.LintCategory.TRY, resVar.pos(),
  30.823 +                        reportWarning(Lint.LintCategory.TRY, resVar.pos(),
  30.824                                      "try.resource.not.referenced", resVar.sym);
  30.825                          unrefdResources.remove(resVar.sym);
  30.826                      }
  30.827 @@ -2018,20 +2074,22 @@
  30.828  
  30.829              for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
  30.830                  JCVariableDecl param = l.head.param;
  30.831 -                inits.assign(initsCatchPrev);
  30.832 +                assignToInits(tree.body, initsCatchPrev);
  30.833                  uninits.assign(uninitsCatchPrev);
  30.834                  scan(param);
  30.835 -                inits.incl(param.sym.adr);
  30.836 -                uninits.excl(param.sym.adr);
  30.837 +                /* If this is a TWR and we are executing the code from Gen,
  30.838 +                 * then there can be synthetic variables, ignore them.
  30.839 +                 */
  30.840 +                initParam(param);
  30.841                  scan(l.head.body);
  30.842                  initsEnd.andSet(inits);
  30.843                  uninitsEnd.andSet(uninits);
  30.844                  nextadr = nextadrCatch;
  30.845              }
  30.846              if (tree.finalizer != null) {
  30.847 -                inits.assign(initsTry);
  30.848 +                assignToInits(tree.finalizer, initsTry);
  30.849                  uninits.assign(uninitsTry);
  30.850 -                ListBuffer<AssignPendingExit> exits = pendingExits;
  30.851 +                ListBuffer<P> exits = pendingExits;
  30.852                  pendingExits = prevPendingExits;
  30.853                  scan(tree.finalizer);
  30.854                  if (!tree.finallyCanCompleteNormally) {
  30.855 @@ -2041,19 +2099,19 @@
  30.856                      // FIX: this doesn't preserve source order of exits in catch
  30.857                      // versus finally!
  30.858                      while (exits.nonEmpty()) {
  30.859 -                        AssignPendingExit exit = exits.next();
  30.860 +                        P exit = exits.next();
  30.861                          if (exit.exit_inits != null) {
  30.862                              exit.exit_inits.orSet(inits);
  30.863                              exit.exit_uninits.andSet(uninits);
  30.864                          }
  30.865                          pendingExits.append(exit);
  30.866                      }
  30.867 -                    inits.orSet(initsEnd);
  30.868 +                    orSetInits(tree, initsEnd);
  30.869                  }
  30.870              } else {
  30.871 -                inits.assign(initsEnd);
  30.872 +                assignToInits(tree, initsEnd);
  30.873                  uninits.assign(uninitsEnd);
  30.874 -                ListBuffer<AssignPendingExit> exits = pendingExits;
  30.875 +                ListBuffer<P> exits = pendingExits;
  30.876                  pendingExits = prevPendingExits;
  30.877                  while (exits.nonEmpty()) pendingExits.append(exits.next());
  30.878              }
  30.879 @@ -2064,7 +2122,7 @@
  30.880              scanCond(tree.cond);
  30.881              final Bits initsBeforeElse = new Bits(initsWhenFalse);
  30.882              final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
  30.883 -            inits.assign(initsWhenTrue);
  30.884 +            assignToInits(tree.cond, initsWhenTrue);
  30.885              uninits.assign(uninitsWhenTrue);
  30.886              if (tree.truepart.type.hasTag(BOOLEAN) &&
  30.887                  tree.falsepart.type.hasTag(BOOLEAN)) {
  30.888 @@ -2077,7 +2135,7 @@
  30.889                  final Bits initsAfterThenWhenFalse = new Bits(initsWhenFalse);
  30.890                  final Bits uninitsAfterThenWhenTrue = new Bits(uninitsWhenTrue);
  30.891                  final Bits uninitsAfterThenWhenFalse = new Bits(uninitsWhenFalse);
  30.892 -                inits.assign(initsBeforeElse);
  30.893 +                assignToInits(tree.truepart, initsBeforeElse);
  30.894                  uninits.assign(uninitsBeforeElse);
  30.895                  scanCond(tree.falsepart);
  30.896                  initsWhenTrue.andSet(initsAfterThenWhenTrue);
  30.897 @@ -2088,10 +2146,10 @@
  30.898                  scanExpr(tree.truepart);
  30.899                  final Bits initsAfterThen = new Bits(inits);
  30.900                  final Bits uninitsAfterThen = new Bits(uninits);
  30.901 -                inits.assign(initsBeforeElse);
  30.902 +                assignToInits(tree.truepart, initsBeforeElse);
  30.903                  uninits.assign(uninitsBeforeElse);
  30.904                  scanExpr(tree.falsepart);
  30.905 -                inits.andSet(initsAfterThen);
  30.906 +                andSetInits(tree.falsepart, initsAfterThen);
  30.907                  uninits.andSet(uninitsAfterThen);
  30.908              }
  30.909          }
  30.910 @@ -2100,39 +2158,46 @@
  30.911              scanCond(tree.cond);
  30.912              final Bits initsBeforeElse = new Bits(initsWhenFalse);
  30.913              final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
  30.914 -            inits.assign(initsWhenTrue);
  30.915 +            assignToInits(tree.cond, initsWhenTrue);
  30.916              uninits.assign(uninitsWhenTrue);
  30.917              scan(tree.thenpart);
  30.918              if (tree.elsepart != null) {
  30.919                  final Bits initsAfterThen = new Bits(inits);
  30.920                  final Bits uninitsAfterThen = new Bits(uninits);
  30.921 -                inits.assign(initsBeforeElse);
  30.922 +                assignToInits(tree.thenpart, initsBeforeElse);
  30.923                  uninits.assign(uninitsBeforeElse);
  30.924                  scan(tree.elsepart);
  30.925 -                inits.andSet(initsAfterThen);
  30.926 +                andSetInits(tree.elsepart, initsAfterThen);
  30.927                  uninits.andSet(uninitsAfterThen);
  30.928              } else {
  30.929 -                inits.andSet(initsBeforeElse);
  30.930 +                andSetInits(tree.thenpart, initsBeforeElse);
  30.931                  uninits.andSet(uninitsBeforeElse);
  30.932              }
  30.933          }
  30.934  
  30.935 -        public void visitBreak(JCBreak tree) {
  30.936 -            recordExit(tree, new AssignPendingExit(tree, inits, uninits));
  30.937 +        protected P createNewPendingExit(JCTree tree, Bits inits, Bits uninits) {
  30.938 +            return null;
  30.939          }
  30.940  
  30.941 -        public void visitContinue(JCContinue tree) {
  30.942 -            recordExit(tree, new AssignPendingExit(tree, inits, uninits));
  30.943 +        @Override
  30.944 +        public void visitBreak(JCBreak tree) {
  30.945 +            recordExit(tree, createNewPendingExit(tree, inits, uninits));
  30.946          }
  30.947  
  30.948 +        @Override
  30.949 +        public void visitContinue(JCContinue tree) {
  30.950 +            recordExit(tree, createNewPendingExit(tree, inits, uninits));
  30.951 +        }
  30.952 +
  30.953 +        @Override
  30.954          public void visitReturn(JCReturn tree) {
  30.955              scanExpr(tree.expr);
  30.956 -            recordExit(tree, new AssignPendingExit(tree, inits, uninits));
  30.957 +            recordExit(tree, createNewPendingExit(tree, inits, uninits));
  30.958          }
  30.959  
  30.960          public void visitThrow(JCThrow tree) {
  30.961              scanExpr(tree.expr);
  30.962 -            markDead();
  30.963 +            markDead(tree.expr);
  30.964          }
  30.965  
  30.966          public void visitApply(JCMethodInvocation tree) {
  30.967 @@ -2151,10 +2216,10 @@
  30.968              final Bits prevUninits = new Bits(uninits);
  30.969              final Bits prevInits = new Bits(inits);
  30.970              int returnadrPrev = returnadr;
  30.971 -            ListBuffer<AssignPendingExit> prevPending = pendingExits;
  30.972 +            ListBuffer<P> prevPending = pendingExits;
  30.973              try {
  30.974                  returnadr = nextadr;
  30.975 -                pendingExits = new ListBuffer<AssignPendingExit>();
  30.976 +                pendingExits = new ListBuffer<P>();
  30.977                  for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
  30.978                      JCVariableDecl def = l.head;
  30.979                      scan(def);
  30.980 @@ -2170,7 +2235,7 @@
  30.981              finally {
  30.982                  returnadr = returnadrPrev;
  30.983                  uninits.assign(prevUninits);
  30.984 -                inits.assign(prevInits);
  30.985 +                assignToInits(tree, prevInits);
  30.986                  pendingExits = prevPending;
  30.987              }
  30.988          }
  30.989 @@ -2186,11 +2251,11 @@
  30.990              scanCond(tree.cond);
  30.991              uninitsExit.andSet(uninitsWhenTrue);
  30.992              if (tree.detail != null) {
  30.993 -                inits.assign(initsWhenFalse);
  30.994 +                assignToInits(tree, initsWhenFalse);
  30.995                  uninits.assign(uninitsWhenFalse);
  30.996                  scanExpr(tree.detail);
  30.997              }
  30.998 -            inits.assign(initsExit);
  30.999 +            assignToInits(tree, initsExit);
 30.1000              uninits.assign(uninitsExit);
 30.1001          }
 30.1002  
 30.1003 @@ -2236,7 +2301,7 @@
 30.1004                  scanCond(tree.lhs);
 30.1005                  final Bits initsWhenFalseLeft = new Bits(initsWhenFalse);
 30.1006                  final Bits uninitsWhenFalseLeft = new Bits(uninitsWhenFalse);
 30.1007 -                inits.assign(initsWhenTrue);
 30.1008 +                assignToInits(tree.lhs, initsWhenTrue);
 30.1009                  uninits.assign(uninitsWhenTrue);
 30.1010                  scanCond(tree.rhs);
 30.1011                  initsWhenFalse.andSet(initsWhenFalseLeft);
 30.1012 @@ -2246,7 +2311,7 @@
 30.1013                  scanCond(tree.lhs);
 30.1014                  final Bits initsWhenTrueLeft = new Bits(initsWhenTrue);
 30.1015                  final Bits uninitsWhenTrueLeft = new Bits(uninitsWhenTrue);
 30.1016 -                inits.assign(initsWhenFalse);
 30.1017 +                assignToInits(tree.lhs, initsWhenFalse);
 30.1018                  uninits.assign(uninitsWhenFalse);
 30.1019                  scanCond(tree.rhs);
 30.1020                  initsWhenTrue.andSet(initsWhenTrueLeft);
 30.1021 @@ -2284,14 +2349,12 @@
 30.1022  
 30.1023          /** Perform definite assignment/unassignment analysis on a tree.
 30.1024           */
 30.1025 -        public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
 30.1026 -            analyzeTree(env, env.tree, make);
 30.1027 -        }
 30.1028 +        public void analyzeTree(Env<?> env) {
 30.1029 +            analyzeTree(env, env.tree);
 30.1030 +         }
 30.1031  
 30.1032 -        public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
 30.1033 +        public void analyzeTree(Env<?> env, JCTree tree) {
 30.1034              try {
 30.1035 -                attrEnv = env;
 30.1036 -                Flow.this.make = make;
 30.1037                  startPos = tree.pos().getStartPosition();
 30.1038  
 30.1039                  if (vardecls == null)
 30.1040 @@ -2301,7 +2364,7 @@
 30.1041                          vardecls[i] = null;
 30.1042                  firstadr = 0;
 30.1043                  nextadr = 0;
 30.1044 -                pendingExits = new ListBuffer<AssignPendingExit>();
 30.1045 +                pendingExits = new ListBuffer<>();
 30.1046                  this.classDef = null;
 30.1047                  unrefdResources = new Scope(env.enclClass.sym);
 30.1048                  scan(tree);
 30.1049 @@ -2310,18 +2373,160 @@
 30.1050                  startPos = -1;
 30.1051                  resetBits(inits, uninits, uninitsTry, initsWhenTrue,
 30.1052                          initsWhenFalse, uninitsWhenTrue, uninitsWhenFalse);
 30.1053 -                if (vardecls != null) for (int i=0; i<vardecls.length; i++)
 30.1054 -                    vardecls[i] = null;
 30.1055 +                if (vardecls != null) {
 30.1056 +                    for (int i=0; i<vardecls.length; i++)
 30.1057 +                        vardecls[i] = null;
 30.1058 +                }
 30.1059                  firstadr = 0;
 30.1060                  nextadr = 0;
 30.1061                  pendingExits = null;
 30.1062 -                Flow.this.make = null;
 30.1063                  this.classDef = null;
 30.1064                  unrefdResources = null;
 30.1065              }
 30.1066          }
 30.1067      }
 30.1068  
 30.1069 +    public static class AssignAnalyzer
 30.1070 +        extends AbstractAssignAnalyzer<AssignAnalyzer.AssignPendingExit> {
 30.1071 +
 30.1072 +        Log log;
 30.1073 +        Lint lint;
 30.1074 +
 30.1075 +        public static class AssignPendingExit
 30.1076 +            extends AbstractAssignAnalyzer.AbstractAssignPendingExit {
 30.1077 +
 30.1078 +            public AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
 30.1079 +                super(tree, inits, uninits);
 30.1080 +            }
 30.1081 +        }
 30.1082 +
 30.1083 +        public AssignAnalyzer(Log log, Symtab syms, Lint lint, Names names) {
 30.1084 +            super(new Bits(), syms, names);
 30.1085 +            this.log = log;
 30.1086 +            this.lint = lint;
 30.1087 +        }
 30.1088 +
 30.1089 +        @Override
 30.1090 +        protected AssignPendingExit createNewPendingExit(JCTree tree,
 30.1091 +            Bits inits, Bits uninits) {
 30.1092 +            return new AssignPendingExit(tree, inits, uninits);
 30.1093 +        }
 30.1094 +
 30.1095 +        /** Record an initialization of a trackable variable.
 30.1096 +         */
 30.1097 +        @Override
 30.1098 +        void letInit(DiagnosticPosition pos, VarSymbol sym) {
 30.1099 +            if (sym.adr >= firstadr && trackable(sym)) {
 30.1100 +                if ((sym.flags() & EFFECTIVELY_FINAL) != 0) {
 30.1101 +                    if (!uninits.isMember(sym.adr)) {
 30.1102 +                        //assignment targeting an effectively final variable
 30.1103 +                        //makes the variable lose its status of effectively final
 30.1104 +                        //if the variable is _not_ definitively unassigned
 30.1105 +                        sym.flags_field &= ~EFFECTIVELY_FINAL;
 30.1106 +                    } else {
 30.1107 +                        uninit(sym);
 30.1108 +                    }
 30.1109 +                }
 30.1110 +                else if ((sym.flags() & FINAL) != 0) {
 30.1111 +                    if ((sym.flags() & PARAMETER) != 0) {
 30.1112 +                        if ((sym.flags() & UNION) != 0) { //multi-catch parameter
 30.1113 +                            log.error(pos, "multicatch.parameter.may.not.be.assigned", sym);
 30.1114 +                        }
 30.1115 +                        else {
 30.1116 +                            log.error(pos, "final.parameter.may.not.be.assigned",
 30.1117 +                                  sym);
 30.1118 +                        }
 30.1119 +                    } else if (!uninits.isMember(sym.adr)) {
 30.1120 +                        log.error(pos, flowKind.errKey, sym);
 30.1121 +                    } else {
 30.1122 +                        uninit(sym);
 30.1123 +                    }
 30.1124 +                }
 30.1125 +                inits.incl(sym.adr);
 30.1126 +            } else if ((sym.flags() & FINAL) != 0) {
 30.1127 +                log.error(pos, "var.might.already.be.assigned", sym);
 30.1128 +            }
 30.1129 +        }
 30.1130 +
 30.1131 +        @Override
 30.1132 +        void checkInit(DiagnosticPosition pos, VarSymbol sym, String errkey) {
 30.1133 +            if ((sym.adr >= firstadr || sym.owner.kind != TYP) &&
 30.1134 +                trackable(sym) &&
 30.1135 +                !inits.isMember(sym.adr)) {
 30.1136 +                log.error(pos, errkey, sym);
 30.1137 +                inits.incl(sym.adr);
 30.1138 +            }
 30.1139 +        }
 30.1140 +
 30.1141 +        @Override
 30.1142 +        void reportWarning(Lint.LintCategory lc, DiagnosticPosition pos,
 30.1143 +            String key, Object ... args) {
 30.1144 +            log.warning(lc, pos, key, args);
 30.1145 +        }
 30.1146 +
 30.1147 +        @Override
 30.1148 +        int getLogNumberOfErrors() {
 30.1149 +            return log.nerrors;
 30.1150 +        }
 30.1151 +
 30.1152 +        @Override
 30.1153 +        boolean isEnabled(Lint.LintCategory lc) {
 30.1154 +            return lint.isEnabled(lc);
 30.1155 +        }
 30.1156 +
 30.1157 +        @Override
 30.1158 +        public void visitClassDef(JCClassDecl tree) {
 30.1159 +            if (tree.sym == null) {
 30.1160 +                return;
 30.1161 +            }
 30.1162 +
 30.1163 +            Lint lintPrev = lint;
 30.1164 +            lint = lint.augment(tree.sym);
 30.1165 +            try {
 30.1166 +                super.visitClassDef(tree);
 30.1167 +            } finally {
 30.1168 +                lint = lintPrev;
 30.1169 +            }
 30.1170 +        }
 30.1171 +
 30.1172 +        @Override
 30.1173 +        public void visitMethodDef(JCMethodDecl tree) {
 30.1174 +            if (tree.body == null) {
 30.1175 +                return;
 30.1176 +            }
 30.1177 +
 30.1178 +            /*  MemberEnter can generate synthetic methods ignore them
 30.1179 +             */
 30.1180 +            if ((tree.sym.flags() & SYNTHETIC) != 0) {
 30.1181 +                return;
 30.1182 +            }
 30.1183 +
 30.1184 +            Lint lintPrev = lint;
 30.1185 +            lint = lint.augment(tree.sym);
 30.1186 +            try {
 30.1187 +                super.visitMethodDef(tree);
 30.1188 +            } finally {
 30.1189 +                lint = lintPrev;
 30.1190 +            }
 30.1191 +        }
 30.1192 +
 30.1193 +        @Override
 30.1194 +        public void visitVarDef(JCVariableDecl tree) {
 30.1195 +            if (tree.init == null) {
 30.1196 +                super.visitVarDef(tree);
 30.1197 +            } else {
 30.1198 +                Lint lintPrev = lint;
 30.1199 +                lint = lint.augment(tree.sym);
 30.1200 +                try{
 30.1201 +                    super.visitVarDef(tree);
 30.1202 +                } finally {
 30.1203 +                    lint = lintPrev;
 30.1204 +                }
 30.1205 +            }
 30.1206 +        }
 30.1207 +
 30.1208 +    }
 30.1209 +
 30.1210      /**
 30.1211       * This pass implements the last step of the dataflow analysis, namely
 30.1212       * the effectively-final analysis check. This checks that every local variable
 30.1213 @@ -2334,7 +2539,7 @@
 30.1214          JCTree currentTree; //local class or lambda
 30.1215  
 30.1216          @Override
 30.1217 -        void markDead() {
 30.1218 +        void markDead(JCTree tree) {
 30.1219              //do nothing
 30.1220          }
 30.1221