langtools/src/share/classes/com/sun/tools/javac/comp/Check.java
author mcimadamore
Thu, 06 Oct 2011 18:39:31 +0100
changeset 10721 ca322e50ddb7
parent 10626 83f0c2860f5b
child 10950 e87b50888909
permissions -rw-r--r--
7090499: missing rawtypes warnings in anonymous inner class Summary: javac does not detect raw types inside anonymous inner classes Reviewed-by: jjg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     1
/*
8031
d5fe2c1cecfc 6992999: fully remove JSR 308 from langtools
jjg
parents: 7681
diff changeset
     2
 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
06bc494ca11e Initial load
duke
parents:
diff changeset
     4
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
06bc494ca11e Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5489
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5489
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    10
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
06bc494ca11e Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
06bc494ca11e Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
06bc494ca11e Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
06bc494ca11e Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
06bc494ca11e Initial load
duke
parents:
diff changeset
    16
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
06bc494ca11e Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
06bc494ca11e Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
06bc494ca11e Initial load
duke
parents:
diff changeset
    20
 *
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5489
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5489
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5489
diff changeset
    23
 * questions.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    24
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    25
06bc494ca11e Initial load
duke
parents:
diff changeset
    26
package com.sun.tools.javac.comp;
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
06bc494ca11e Initial load
duke
parents:
diff changeset
    28
import java.util.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    29
import java.util.Set;
06bc494ca11e Initial load
duke
parents:
diff changeset
    30
06bc494ca11e Initial load
duke
parents:
diff changeset
    31
import com.sun.tools.javac.code.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    32
import com.sun.tools.javac.jvm.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    33
import com.sun.tools.javac.tree.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    34
import com.sun.tools.javac.util.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    35
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
06bc494ca11e Initial load
duke
parents:
diff changeset
    36
import com.sun.tools.javac.util.List;
06bc494ca11e Initial load
duke
parents:
diff changeset
    37
06bc494ca11e Initial load
duke
parents:
diff changeset
    38
import com.sun.tools.javac.tree.JCTree.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    39
import com.sun.tools.javac.code.Lint;
06bc494ca11e Initial load
duke
parents:
diff changeset
    40
import com.sun.tools.javac.code.Lint.LintCategory;
06bc494ca11e Initial load
duke
parents:
diff changeset
    41
import com.sun.tools.javac.code.Type.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    42
import com.sun.tools.javac.code.Symbol.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    43
06bc494ca11e Initial load
duke
parents:
diff changeset
    44
import static com.sun.tools.javac.code.Flags.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    45
import static com.sun.tools.javac.code.Kinds.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    46
import static com.sun.tools.javac.code.TypeTags.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    47
6721
d92073844278 6988436: Cleanup javac option handling
jjg
parents: 6711
diff changeset
    48
import static com.sun.tools.javac.main.OptionName.*;
d92073844278 6988436: Cleanup javac option handling
jjg
parents: 6711
diff changeset
    49
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    50
/** Type checking helper class for the attribution phase.
06bc494ca11e Initial load
duke
parents:
diff changeset
    51
 *
5847
1908176fd6e3 6944312: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
    52
 *  <p><b>This is NOT part of any supported API.
1908176fd6e3 6944312: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
    53
 *  If you write code that depends on this, you do so at your own risk.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    54
 *  This code and its internal interfaces are subject to change or
06bc494ca11e Initial load
duke
parents:
diff changeset
    55
 *  deletion without notice.</b>
06bc494ca11e Initial load
duke
parents:
diff changeset
    56
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    57
public class Check {
06bc494ca11e Initial load
duke
parents:
diff changeset
    58
    protected static final Context.Key<Check> checkKey =
06bc494ca11e Initial load
duke
parents:
diff changeset
    59
        new Context.Key<Check>();
06bc494ca11e Initial load
duke
parents:
diff changeset
    60
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1257
diff changeset
    61
    private final Names names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    62
    private final Log log;
06bc494ca11e Initial load
duke
parents:
diff changeset
    63
    private final Symtab syms;
6711
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
    64
    private final Enter enter;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    65
    private final Infer infer;
06bc494ca11e Initial load
duke
parents:
diff changeset
    66
    private final Types types;
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
    67
    private final JCDiagnostic.Factory diags;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    68
    private final boolean skipAnnotations;
3557
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
    69
    private boolean warnOnSyntheticConflicts;
5842
714e365b4b1b 6955264: add option to suppress Abort in Check.completionError
jjg
parents: 5654
diff changeset
    70
    private boolean suppressAbortOnBadClassFile;
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
    71
    private boolean enableSunApiLintControl;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    72
    private final TreeInfo treeinfo;
06bc494ca11e Initial load
duke
parents:
diff changeset
    73
06bc494ca11e Initial load
duke
parents:
diff changeset
    74
    // The set of lint options currently in effect. It is initialized
06bc494ca11e Initial load
duke
parents:
diff changeset
    75
    // from the context, and then is set/reset as needed by Attr as it
06bc494ca11e Initial load
duke
parents:
diff changeset
    76
    // visits all the various parts of the trees during attribution.
06bc494ca11e Initial load
duke
parents:
diff changeset
    77
    private Lint lint;
06bc494ca11e Initial load
duke
parents:
diff changeset
    78
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
    79
    // The method being analyzed in Attr - it is set/reset as needed by
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
    80
    // Attr as it visits new method declarations.
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
    81
    private MethodSymbol method;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
    82
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    83
    public static Check instance(Context context) {
06bc494ca11e Initial load
duke
parents:
diff changeset
    84
        Check instance = context.get(checkKey);
06bc494ca11e Initial load
duke
parents:
diff changeset
    85
        if (instance == null)
06bc494ca11e Initial load
duke
parents:
diff changeset
    86
            instance = new Check(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
    87
        return instance;
06bc494ca11e Initial load
duke
parents:
diff changeset
    88
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
    89
06bc494ca11e Initial load
duke
parents:
diff changeset
    90
    protected Check(Context context) {
06bc494ca11e Initial load
duke
parents:
diff changeset
    91
        context.put(checkKey, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
    92
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1257
diff changeset
    93
        names = Names.instance(context);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    94
        log = Log.instance(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
    95
        syms = Symtab.instance(context);
6711
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
    96
        enter = Enter.instance(context);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    97
        infer = Infer.instance(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
    98
        this.types = Types.instance(context);
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
    99
        diags = JCDiagnostic.Factory.instance(context);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   100
        Options options = Options.instance(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
   101
        lint = Lint.instance(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
   102
        treeinfo = TreeInfo.instance(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
   103
06bc494ca11e Initial load
duke
parents:
diff changeset
   104
        Source source = Source.instance(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
   105
        allowGenerics = source.allowGenerics();
06bc494ca11e Initial load
duke
parents:
diff changeset
   106
        allowAnnotations = source.allowAnnotations();
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   107
        allowCovariantReturns = source.allowCovariantReturns();
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   108
        allowSimplifiedVarargs = source.allowSimplifiedVarargs();
6721
d92073844278 6988436: Cleanup javac option handling
jjg
parents: 6711
diff changeset
   109
        complexInference = options.isSet(COMPLEXINFERENCE);
d92073844278 6988436: Cleanup javac option handling
jjg
parents: 6711
diff changeset
   110
        skipAnnotations = options.isSet("skipAnnotations");
d92073844278 6988436: Cleanup javac option handling
jjg
parents: 6711
diff changeset
   111
        warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
d92073844278 6988436: Cleanup javac option handling
jjg
parents: 6711
diff changeset
   112
        suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   113
        enableSunApiLintControl = options.isSet("enableSunApiLintControl");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   114
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   115
        Target target = Target.instance(context);
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   116
        syntheticNameChar = target.syntheticNameChar();
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   117
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   118
        boolean verboseDeprecated = lint.isEnabled(LintCategory.DEPRECATION);
06bc494ca11e Initial load
duke
parents:
diff changeset
   119
        boolean verboseUnchecked = lint.isEnabled(LintCategory.UNCHECKED);
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   120
        boolean verboseSunApi = lint.isEnabled(LintCategory.SUNAPI);
813
ab91293d33f4 6507179: javadoc -source 1.3 does not work with jdk6
jjg
parents: 812
diff changeset
   121
        boolean enforceMandatoryWarnings = source.enforceMandatoryWarnings();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   122
813
ab91293d33f4 6507179: javadoc -source 1.3 does not work with jdk6
jjg
parents: 812
diff changeset
   123
        deprecationHandler = new MandatoryWarningHandler(log, verboseDeprecated,
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   124
                enforceMandatoryWarnings, "deprecated", LintCategory.DEPRECATION);
813
ab91293d33f4 6507179: javadoc -source 1.3 does not work with jdk6
jjg
parents: 812
diff changeset
   125
        uncheckedHandler = new MandatoryWarningHandler(log, verboseUnchecked,
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   126
                enforceMandatoryWarnings, "unchecked", LintCategory.UNCHECKED);
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   127
        sunApiHandler = new MandatoryWarningHandler(log, verboseSunApi,
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   128
                enforceMandatoryWarnings, "sunapi", null);
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   129
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   130
        deferredLintHandler = DeferredLintHandler.immediateHandler;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   131
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   132
06bc494ca11e Initial load
duke
parents:
diff changeset
   133
    /** Switch: generics enabled?
06bc494ca11e Initial load
duke
parents:
diff changeset
   134
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   135
    boolean allowGenerics;
06bc494ca11e Initial load
duke
parents:
diff changeset
   136
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
    /** Switch: annotations enabled?
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
    boolean allowAnnotations;
06bc494ca11e Initial load
duke
parents:
diff changeset
   140
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   141
    /** Switch: covariant returns enabled?
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   142
     */
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   143
    boolean allowCovariantReturns;
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   144
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   145
    /** Switch: simplified varargs enabled?
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   146
     */
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   147
    boolean allowSimplifiedVarargs;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   148
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   149
    /** Switch: -complexinference option set?
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   151
    boolean complexInference;
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   153
    /** Character for synthetic names
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   154
     */
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   155
    char syntheticNameChar;
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   156
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   157
    /** A table mapping flat names of all compiled classes in this run to their
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
     *  symbols; maintained from outside.
06bc494ca11e Initial load
duke
parents:
diff changeset
   159
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
    public Map<Name,ClassSymbol> compiled = new HashMap<Name, ClassSymbol>();
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
06bc494ca11e Initial load
duke
parents:
diff changeset
   162
    /** A handler for messages about deprecated usage.
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   164
    private MandatoryWarningHandler deprecationHandler;
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
06bc494ca11e Initial load
duke
parents:
diff changeset
   166
    /** A handler for messages about unchecked or unsafe usage.
06bc494ca11e Initial load
duke
parents:
diff changeset
   167
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   168
    private MandatoryWarningHandler uncheckedHandler;
06bc494ca11e Initial load
duke
parents:
diff changeset
   169
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5847
diff changeset
   170
    /** A handler for messages about using proprietary API.
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   171
     */
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   172
    private MandatoryWarningHandler sunApiHandler;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   174
    /** A handler for deferred lint warnings.
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   175
     */
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   176
    private DeferredLintHandler deferredLintHandler;
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   177
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   178
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
   179
 * Errors and Warnings
06bc494ca11e Initial load
duke
parents:
diff changeset
   180
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
   181
06bc494ca11e Initial load
duke
parents:
diff changeset
   182
    Lint setLint(Lint newLint) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   183
        Lint prev = lint;
06bc494ca11e Initial load
duke
parents:
diff changeset
   184
        lint = newLint;
06bc494ca11e Initial load
duke
parents:
diff changeset
   185
        return prev;
06bc494ca11e Initial load
duke
parents:
diff changeset
   186
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   187
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   188
    DeferredLintHandler setDeferredLintHandler(DeferredLintHandler newDeferredLintHandler) {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   189
        DeferredLintHandler prev = deferredLintHandler;
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   190
        deferredLintHandler = newDeferredLintHandler;
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   191
        return prev;
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   192
    }
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
   193
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   194
    MethodSymbol setMethod(MethodSymbol newMethod) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   195
        MethodSymbol prev = method;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   196
        method = newMethod;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   197
        return prev;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   198
    }
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   199
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   200
    /** Warn about deprecated symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   202
     *  @param sym        The deprecated symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   203
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
    void warnDeprecated(DiagnosticPosition pos, Symbol sym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   205
        if (!lint.isSuppressed(LintCategory.DEPRECATION))
06bc494ca11e Initial load
duke
parents:
diff changeset
   206
            deprecationHandler.report(pos, "has.been.deprecated", sym, sym.location());
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   208
06bc494ca11e Initial load
duke
parents:
diff changeset
   209
    /** Warn about unchecked operation.
06bc494ca11e Initial load
duke
parents:
diff changeset
   210
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   211
     *  @param msg        A string describing the problem.
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   213
    public void warnUnchecked(DiagnosticPosition pos, String msg, Object... args) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   214
        if (!lint.isSuppressed(LintCategory.UNCHECKED))
06bc494ca11e Initial load
duke
parents:
diff changeset
   215
            uncheckedHandler.report(pos, msg, args);
06bc494ca11e Initial load
duke
parents:
diff changeset
   216
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   217
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   218
    /** Warn about unsafe vararg method decl.
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   219
     *  @param pos        Position to be used for error reporting.
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   220
     *  @param sym        The deprecated symbol.
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   221
     */
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   222
    void warnUnsafeVararg(DiagnosticPosition pos, String key, Object... args) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   223
        if (lint.isEnabled(LintCategory.VARARGS) && allowSimplifiedVarargs)
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   224
            log.warning(LintCategory.VARARGS, pos, key, args);
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   225
    }
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   226
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5847
diff changeset
   227
    /** Warn about using proprietary API.
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   228
     *  @param pos        Position to be used for error reporting.
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   229
     *  @param msg        A string describing the problem.
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   230
     */
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   231
    public void warnSunApi(DiagnosticPosition pos, String msg, Object... args) {
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   232
        if (!lint.isSuppressed(LintCategory.SUNAPI))
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   233
            sunApiHandler.report(pos, msg, args);
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   234
    }
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   235
5002
12a9e8562200 4880220: Add a warning when accessing a static method via an reference
jjg
parents: 4867
diff changeset
   236
    public void warnStatic(DiagnosticPosition pos, String msg, Object... args) {
12a9e8562200 4880220: Add a warning when accessing a static method via an reference
jjg
parents: 4867
diff changeset
   237
        if (lint.isEnabled(LintCategory.STATIC))
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   238
            log.warning(LintCategory.STATIC, pos, msg, args);
5002
12a9e8562200 4880220: Add a warning when accessing a static method via an reference
jjg
parents: 4867
diff changeset
   239
    }
12a9e8562200 4880220: Add a warning when accessing a static method via an reference
jjg
parents: 4867
diff changeset
   240
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   241
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   242
     * Report any deferred diagnostics.
06bc494ca11e Initial load
duke
parents:
diff changeset
   243
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   244
    public void reportDeferredDiagnostics() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   245
        deprecationHandler.reportDeferredDiagnostic();
06bc494ca11e Initial load
duke
parents:
diff changeset
   246
        uncheckedHandler.reportDeferredDiagnostic();
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   247
        sunApiHandler.reportDeferredDiagnostic();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   248
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   249
06bc494ca11e Initial load
duke
parents:
diff changeset
   250
06bc494ca11e Initial load
duke
parents:
diff changeset
   251
    /** Report a failure to complete a class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   252
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   253
     *  @param ex         The failure to report.
06bc494ca11e Initial load
duke
parents:
diff changeset
   254
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   255
    public Type completionError(DiagnosticPosition pos, CompletionFailure ex) {
169
ff76730e430e 6668794: javac puts localized text in raw diagnostics
jjg
parents: 10
diff changeset
   256
        log.error(pos, "cant.access", ex.sym, ex.getDetailValue());
5842
714e365b4b1b 6955264: add option to suppress Abort in Check.completionError
jjg
parents: 5654
diff changeset
   257
        if (ex instanceof ClassReader.BadClassFile
714e365b4b1b 6955264: add option to suppress Abort in Check.completionError
jjg
parents: 5654
diff changeset
   258
                && !suppressAbortOnBadClassFile) throw new Abort();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   259
        else return syms.errType;
06bc494ca11e Initial load
duke
parents:
diff changeset
   260
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   261
06bc494ca11e Initial load
duke
parents:
diff changeset
   262
    /** Report a type error.
06bc494ca11e Initial load
duke
parents:
diff changeset
   263
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   264
     *  @param problem    A string describing the error.
06bc494ca11e Initial load
duke
parents:
diff changeset
   265
     *  @param found      The type that was found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   266
     *  @param req        The type that was required.
06bc494ca11e Initial load
duke
parents:
diff changeset
   267
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   268
    Type typeError(DiagnosticPosition pos, Object problem, Type found, Type req) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   269
        log.error(pos, "prob.found.req",
06bc494ca11e Initial load
duke
parents:
diff changeset
   270
                  problem, found, req);
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   271
        return types.createErrorType(found);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   272
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   273
06bc494ca11e Initial load
duke
parents:
diff changeset
   274
    Type typeError(DiagnosticPosition pos, String problem, Type found, Type req, Object explanation) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   275
        log.error(pos, "prob.found.req.1", problem, found, req, explanation);
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   276
        return types.createErrorType(found);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   277
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   278
06bc494ca11e Initial load
duke
parents:
diff changeset
   279
    /** Report an error that wrong type tag was found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   280
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   281
     *  @param required   An internationalized string describing the type tag
06bc494ca11e Initial load
duke
parents:
diff changeset
   282
     *                    required.
06bc494ca11e Initial load
duke
parents:
diff changeset
   283
     *  @param found      The type that was found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   284
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   285
    Type typeTagError(DiagnosticPosition pos, Object required, Object found) {
2723
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   286
        // this error used to be raised by the parser,
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   287
        // but has been delayed to this point:
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   288
        if (found instanceof Type && ((Type)found).tag == VOID) {
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   289
            log.error(pos, "illegal.start.of.type");
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   290
            return syms.errType;
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   291
        }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   292
        log.error(pos, "type.found.req", found, required);
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   293
        return types.createErrorType(found instanceof Type ? (Type)found : syms.errType);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   294
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   295
06bc494ca11e Initial load
duke
parents:
diff changeset
   296
    /** Report an error that symbol cannot be referenced before super
06bc494ca11e Initial load
duke
parents:
diff changeset
   297
     *  has been called.
06bc494ca11e Initial load
duke
parents:
diff changeset
   298
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   299
     *  @param sym        The referenced symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   300
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   301
    void earlyRefError(DiagnosticPosition pos, Symbol sym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   302
        log.error(pos, "cant.ref.before.ctor.called", sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   303
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   304
06bc494ca11e Initial load
duke
parents:
diff changeset
   305
    /** Report duplicate declaration error.
06bc494ca11e Initial load
duke
parents:
diff changeset
   306
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   307
    void duplicateError(DiagnosticPosition pos, Symbol sym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   308
        if (!sym.type.isErroneous()) {
10626
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   309
            Symbol location = sym.location();
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   310
            if (location.kind == MTH &&
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   311
                    ((MethodSymbol)location).isStaticOrInstanceInit()) {
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   312
                log.error(pos, "already.defined.in.clinit", kindName(sym), sym,
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   313
                        kindName(sym.location()), kindName(sym.location().enclClass()),
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   314
                        sym.location().enclClass());
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   315
            } else {
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   316
                log.error(pos, "already.defined", kindName(sym), sym,
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   317
                        kindName(sym.location()), sym.location());
83f0c2860f5b 7086595: Error message bug: name of initializer is 'null'
mcimadamore
parents: 9814
diff changeset
   318
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   319
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   320
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   321
06bc494ca11e Initial load
duke
parents:
diff changeset
   322
    /** Report array/varargs duplicate declaration
06bc494ca11e Initial load
duke
parents:
diff changeset
   323
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   324
    void varargsDuplicateError(DiagnosticPosition pos, Symbol sym1, Symbol sym2) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   325
        if (!sym1.type.isErroneous() && !sym2.type.isErroneous()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   326
            log.error(pos, "array.and.varargs", sym1, sym2, sym2.location());
06bc494ca11e Initial load
duke
parents:
diff changeset
   327
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   328
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   329
06bc494ca11e Initial load
duke
parents:
diff changeset
   330
/* ************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
   331
 * duplicate declaration checking
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
 *************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
   333
06bc494ca11e Initial load
duke
parents:
diff changeset
   334
    /** Check that variable does not hide variable with same name in
06bc494ca11e Initial load
duke
parents:
diff changeset
   335
     *  immediately enclosing local scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   336
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   337
     *  @param v             The symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   338
     *  @param s             The scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   339
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   340
    void checkTransparentVar(DiagnosticPosition pos, VarSymbol v, Scope s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   341
        if (s.next != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   342
            for (Scope.Entry e = s.next.lookup(v.name);
06bc494ca11e Initial load
duke
parents:
diff changeset
   343
                 e.scope != null && e.sym.owner == v.owner;
06bc494ca11e Initial load
duke
parents:
diff changeset
   344
                 e = e.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   345
                if (e.sym.kind == VAR &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   346
                    (e.sym.owner.kind & (VAR | MTH)) != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   347
                    v.name != names.error) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   348
                    duplicateError(pos, e.sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   349
                    return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   350
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   351
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   352
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   353
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   354
06bc494ca11e Initial load
duke
parents:
diff changeset
   355
    /** Check that a class or interface does not hide a class or
06bc494ca11e Initial load
duke
parents:
diff changeset
   356
     *  interface with same name in immediately enclosing local scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   357
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   358
     *  @param c             The symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   359
     *  @param s             The scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   360
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   361
    void checkTransparentClass(DiagnosticPosition pos, ClassSymbol c, Scope s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   362
        if (s.next != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   363
            for (Scope.Entry e = s.next.lookup(c.name);
06bc494ca11e Initial load
duke
parents:
diff changeset
   364
                 e.scope != null && e.sym.owner == c.owner;
06bc494ca11e Initial load
duke
parents:
diff changeset
   365
                 e = e.next()) {
6352
217d5a69681a 6977800: Regression: invalid resolution of supertype for local class
mcimadamore
parents: 6351
diff changeset
   366
                if (e.sym.kind == TYP && e.sym.type.tag != TYPEVAR &&
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   367
                    (e.sym.owner.kind & (VAR | MTH)) != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   368
                    c.name != names.error) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   369
                    duplicateError(pos, e.sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   370
                    return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   371
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   372
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   373
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   374
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   375
06bc494ca11e Initial load
duke
parents:
diff changeset
   376
    /** Check that class does not have the same name as one of
06bc494ca11e Initial load
duke
parents:
diff changeset
   377
     *  its enclosing classes, or as a class defined in its enclosing scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   378
     *  return true if class is unique in its enclosing scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   379
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   380
     *  @param name          The class name.
06bc494ca11e Initial load
duke
parents:
diff changeset
   381
     *  @param s             The enclosing scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
   382
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   383
    boolean checkUniqueClassName(DiagnosticPosition pos, Name name, Scope s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   384
        for (Scope.Entry e = s.lookup(name); e.scope == s; e = e.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   385
            if (e.sym.kind == TYP && e.sym.name != names.error) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   386
                duplicateError(pos, e.sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   387
                return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   388
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   389
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   390
        for (Symbol sym = s.owner; sym != null; sym = sym.owner) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   391
            if (sym.kind == TYP && sym.name == name && sym.name != names.error) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   392
                duplicateError(pos, sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
   393
                return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   394
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   395
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   396
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   397
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   398
06bc494ca11e Initial load
duke
parents:
diff changeset
   399
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
   400
 * Class name generation
06bc494ca11e Initial load
duke
parents:
diff changeset
   401
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
   402
06bc494ca11e Initial load
duke
parents:
diff changeset
   403
    /** Return name of local class.
06bc494ca11e Initial load
duke
parents:
diff changeset
   404
     *  This is of the form    <enclClass> $ n <classname>
06bc494ca11e Initial load
duke
parents:
diff changeset
   405
     *  where
06bc494ca11e Initial load
duke
parents:
diff changeset
   406
     *    enclClass is the flat name of the enclosing class,
06bc494ca11e Initial load
duke
parents:
diff changeset
   407
     *    classname is the simple name of the local class
06bc494ca11e Initial load
duke
parents:
diff changeset
   408
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   409
    Name localClassName(ClassSymbol c) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   410
        for (int i=1; ; i++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   411
            Name flatname = names.
06bc494ca11e Initial load
duke
parents:
diff changeset
   412
                fromString("" + c.owner.enclClass().flatname +
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   413
                           syntheticNameChar + i +
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   414
                           c.name);
06bc494ca11e Initial load
duke
parents:
diff changeset
   415
            if (compiled.get(flatname) == null) return flatname;
06bc494ca11e Initial load
duke
parents:
diff changeset
   416
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   417
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   418
06bc494ca11e Initial load
duke
parents:
diff changeset
   419
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
   420
 * Type Checking
06bc494ca11e Initial load
duke
parents:
diff changeset
   421
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
   422
06bc494ca11e Initial load
duke
parents:
diff changeset
   423
    /** Check that a given type is assignable to a given proto-type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   424
     *  If it is, return the type, otherwise return errType.
06bc494ca11e Initial load
duke
parents:
diff changeset
   425
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   426
     *  @param found      The type that was found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   427
     *  @param req        The type that was required.
06bc494ca11e Initial load
duke
parents:
diff changeset
   428
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   429
    Type checkType(DiagnosticPosition pos, Type found, Type req) {
6148
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6147
diff changeset
   430
        return checkType(pos, found, req, "incompatible.types");
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6147
diff changeset
   431
    }
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6147
diff changeset
   432
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6147
diff changeset
   433
    Type checkType(DiagnosticPosition pos, Type found, Type req, String errKey) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   434
        if (req.tag == ERROR)
06bc494ca11e Initial load
duke
parents:
diff changeset
   435
            return req;
5320
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   436
        if (found.tag == FORALL)
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   437
            return instantiatePoly(pos, (ForAll)found, req, convertWarner(pos, found, req));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   438
        if (req.tag == NONE)
06bc494ca11e Initial load
duke
parents:
diff changeset
   439
            return found;
06bc494ca11e Initial load
duke
parents:
diff changeset
   440
        if (types.isAssignable(found, req, convertWarner(pos, found, req)))
06bc494ca11e Initial load
duke
parents:
diff changeset
   441
            return found;
06bc494ca11e Initial load
duke
parents:
diff changeset
   442
        if (found.tag <= DOUBLE && req.tag <= DOUBLE)
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   443
            return typeError(pos, diags.fragment("possible.loss.of.precision"), found, req);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   444
        if (found.isSuperBound()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   445
            log.error(pos, "assignment.from.super-bound", found);
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   446
            return types.createErrorType(found);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   447
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   448
        if (req.isExtendsBound()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   449
            log.error(pos, "assignment.to.extends-bound", req);
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   450
            return types.createErrorType(found);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   451
        }
6148
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6147
diff changeset
   452
        return typeError(pos, diags.fragment(errKey), found, req);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   453
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   454
06bc494ca11e Initial load
duke
parents:
diff changeset
   455
    /** Instantiate polymorphic type to some prototype, unless
06bc494ca11e Initial load
duke
parents:
diff changeset
   456
     *  prototype is `anyPoly' in which case polymorphic type
06bc494ca11e Initial load
duke
parents:
diff changeset
   457
     *  is returned unchanged.
06bc494ca11e Initial load
duke
parents:
diff changeset
   458
     */
3765
9548183897cb 6840638: Project Coin: Improved Type Inference for Generic Instance Creation (aka 'diamond')
mcimadamore
parents: 3661
diff changeset
   459
    Type instantiatePoly(DiagnosticPosition pos, ForAll t, Type pt, Warner warn) throws Infer.NoInstanceException {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   460
        if (pt == Infer.anyPoly && complexInference) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   461
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   462
        } else if (pt == Infer.anyPoly || pt.tag == NONE) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   463
            Type newpt = t.qtype.tag <= VOID ? t.qtype : syms.objectType;
06bc494ca11e Initial load
duke
parents:
diff changeset
   464
            return instantiatePoly(pos, t, newpt, warn);
06bc494ca11e Initial load
duke
parents:
diff changeset
   465
        } else if (pt.tag == ERROR) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   466
            return pt;
06bc494ca11e Initial load
duke
parents:
diff changeset
   467
        } else {
5320
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   468
            try {
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   469
                return infer.instantiateExpr(t, pt, warn);
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   470
            } catch (Infer.NoInstanceException ex) {
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   471
                if (ex.isAmbiguous) {
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   472
                    JCDiagnostic d = ex.getDiagnostic();
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   473
                    log.error(pos,
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   474
                              "undetermined.type" + (d!=null ? ".1" : ""),
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   475
                              t, d);
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   476
                    return types.createErrorType(pt);
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   477
                } else {
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   478
                    JCDiagnostic d = ex.getDiagnostic();
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   479
                    return typeError(pos,
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   480
                                     diags.fragment("incompatible.types" + (d!=null ? ".1" : ""), d),
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   481
                                     t, pt);
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   482
                }
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   483
            } catch (Infer.InvalidInstanceException ex) {
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   484
                JCDiagnostic d = ex.getDiagnostic();
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   485
                log.error(pos, "invalid.inferred.types", t.tvars, d);
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   486
                return types.createErrorType(pt);
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   487
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   488
        }
5320
e2aaa958b02d 6939618: Revert 'simple' diamond implementation
mcimadamore
parents: 5002
diff changeset
   489
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   490
06bc494ca11e Initial load
duke
parents:
diff changeset
   491
    /** Check that a given type can be cast to a given target type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   492
     *  Return the result of the cast.
06bc494ca11e Initial load
duke
parents:
diff changeset
   493
     *  @param pos        Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   494
     *  @param found      The type that is being cast.
06bc494ca11e Initial load
duke
parents:
diff changeset
   495
     *  @param req        The target type of the cast.
06bc494ca11e Initial load
duke
parents:
diff changeset
   496
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   497
    Type checkCastable(DiagnosticPosition pos, Type found, Type req) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   498
        if (found.tag == FORALL) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   499
            instantiatePoly(pos, (ForAll) found, req, castWarner(pos, found, req));
06bc494ca11e Initial load
duke
parents:
diff changeset
   500
            return req;
06bc494ca11e Initial load
duke
parents:
diff changeset
   501
        } else if (types.isCastable(found, req, castWarner(pos, found, req))) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   502
            return req;
06bc494ca11e Initial load
duke
parents:
diff changeset
   503
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   504
            return typeError(pos,
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   505
                             diags.fragment("inconvertible.types"),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   506
                             found, req);
06bc494ca11e Initial load
duke
parents:
diff changeset
   507
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   508
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   509
//where
06bc494ca11e Initial load
duke
parents:
diff changeset
   510
        /** Is type a type variable, or a (possibly multi-dimensional) array of
06bc494ca11e Initial load
duke
parents:
diff changeset
   511
         *  type variables?
06bc494ca11e Initial load
duke
parents:
diff changeset
   512
         */
06bc494ca11e Initial load
duke
parents:
diff changeset
   513
        boolean isTypeVar(Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   514
            return t.tag == TYPEVAR || t.tag == ARRAY && isTypeVar(types.elemtype(t));
06bc494ca11e Initial load
duke
parents:
diff changeset
   515
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   516
06bc494ca11e Initial load
duke
parents:
diff changeset
   517
    /** Check that a type is within some bounds.
06bc494ca11e Initial load
duke
parents:
diff changeset
   518
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   519
     *  Used in TypeApply to verify that, e.g., X in V<X> is a valid
06bc494ca11e Initial load
duke
parents:
diff changeset
   520
     *  type argument.
06bc494ca11e Initial load
duke
parents:
diff changeset
   521
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   522
     *  @param a             The type that should be bounded by bs.
06bc494ca11e Initial load
duke
parents:
diff changeset
   523
     *  @param bs            The bound.
06bc494ca11e Initial load
duke
parents:
diff changeset
   524
     */
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   525
    private boolean checkExtends(Type a, TypeVar bs) {
1527
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   526
         if (a.isUnbound()) {
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   527
             return true;
1527
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   528
         } else if (a.tag != WILDCARD) {
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   529
             a = types.upperBound(a);
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   530
             return types.isSubtype(a, bs.bound);
1527
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   531
         } else if (a.isExtendsBound()) {
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   532
             return types.isCastable(bs.getUpperBound(), types.upperBound(a), Warner.noWarnings);
1527
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   533
         } else if (a.isSuperBound()) {
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   534
             return !types.notSoftSubtype(types.lowerBound(a), bs.getUpperBound());
1527
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   535
         }
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   536
         return true;
1527
815e743a83ba 6732484: Bound error on wildcard code
mcimadamore
parents: 1358
diff changeset
   537
     }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   538
06bc494ca11e Initial load
duke
parents:
diff changeset
   539
    /** Check that type is different from 'void'.
06bc494ca11e Initial load
duke
parents:
diff changeset
   540
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   541
     *  @param t             The type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   542
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   543
    Type checkNonVoid(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   544
        if (t.tag == VOID) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   545
            log.error(pos, "void.not.allowed.here");
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   546
            return types.createErrorType(t);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   547
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   548
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   549
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   550
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   551
06bc494ca11e Initial load
duke
parents:
diff changeset
   552
    /** Check that type is a class or interface type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   553
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   554
     *  @param t             The type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   555
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   556
    Type checkClassType(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   557
        if (t.tag != CLASS && t.tag != ERROR)
06bc494ca11e Initial load
duke
parents:
diff changeset
   558
            return typeTagError(pos,
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   559
                                diags.fragment("type.req.class"),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   560
                                (t.tag == TYPEVAR)
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   561
                                ? diags.fragment("type.parameter", t)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   562
                                : t);
06bc494ca11e Initial load
duke
parents:
diff changeset
   563
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
   564
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   565
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   566
06bc494ca11e Initial load
duke
parents:
diff changeset
   567
    /** Check that type is a class or interface type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   568
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   569
     *  @param t             The type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   570
     *  @param noBounds    True if type bounds are illegal here.
06bc494ca11e Initial load
duke
parents:
diff changeset
   571
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   572
    Type checkClassType(DiagnosticPosition pos, Type t, boolean noBounds) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   573
        t = checkClassType(pos, t);
06bc494ca11e Initial load
duke
parents:
diff changeset
   574
        if (noBounds && t.isParameterized()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   575
            List<Type> args = t.getTypeArguments();
06bc494ca11e Initial load
duke
parents:
diff changeset
   576
            while (args.nonEmpty()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   577
                if (args.head.tag == WILDCARD)
06bc494ca11e Initial load
duke
parents:
diff changeset
   578
                    return typeTagError(pos,
6032
03b276d8e6a6 6968497: localized text appears in raw diagnostic
jjg
parents: 5848
diff changeset
   579
                                        diags.fragment("type.req.exact"),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   580
                                        args.head);
06bc494ca11e Initial load
duke
parents:
diff changeset
   581
                args = args.tail;
06bc494ca11e Initial load
duke
parents:
diff changeset
   582
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   583
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   584
        return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   585
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   586
06bc494ca11e Initial load
duke
parents:
diff changeset
   587
    /** Check that type is a reifiable class, interface or array type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   588
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   589
     *  @param t             The type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   590
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   591
    Type checkReifiableReferenceType(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   592
        if (t.tag != CLASS && t.tag != ARRAY && t.tag != ERROR) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   593
            return typeTagError(pos,
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   594
                                diags.fragment("type.req.class.array"),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   595
                                t);
06bc494ca11e Initial load
duke
parents:
diff changeset
   596
        } else if (!types.isReifiable(t)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   597
            log.error(pos, "illegal.generic.type.for.instof");
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
   598
            return types.createErrorType(t);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   599
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   600
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   601
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   602
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   603
06bc494ca11e Initial load
duke
parents:
diff changeset
   604
    /** Check that type is a reference type, i.e. a class, interface or array type
06bc494ca11e Initial load
duke
parents:
diff changeset
   605
     *  or a type variable.
06bc494ca11e Initial load
duke
parents:
diff changeset
   606
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   607
     *  @param t             The type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   608
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   609
    Type checkRefType(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   610
        switch (t.tag) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   611
        case CLASS:
06bc494ca11e Initial load
duke
parents:
diff changeset
   612
        case ARRAY:
06bc494ca11e Initial load
duke
parents:
diff changeset
   613
        case TYPEVAR:
06bc494ca11e Initial load
duke
parents:
diff changeset
   614
        case WILDCARD:
06bc494ca11e Initial load
duke
parents:
diff changeset
   615
        case ERROR:
06bc494ca11e Initial load
duke
parents:
diff changeset
   616
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   617
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   618
            return typeTagError(pos,
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   619
                                diags.fragment("type.req.ref"),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   620
                                t);
06bc494ca11e Initial load
duke
parents:
diff changeset
   621
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   622
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   623
2723
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   624
    /** Check that each type is a reference type, i.e. a class, interface or array type
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   625
     *  or a type variable.
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   626
     *  @param trees         Original trees, used for error reporting.
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   627
     *  @param types         The types to be checked.
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   628
     */
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   629
    List<Type> checkRefTypes(List<JCExpression> trees, List<Type> types) {
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   630
        List<JCExpression> tl = trees;
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   631
        for (List<Type> l = types; l.nonEmpty(); l = l.tail) {
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   632
            l.head = checkRefType(tl.head.pos(), l.head);
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   633
            tl = tl.tail;
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   634
        }
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   635
        return types;
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   636
    }
b659ca23d5f5 6829189: Java programming with JSR 292 needs language support
jrose
parents: 2509
diff changeset
   637
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   638
    /** Check that type is a null or reference type.
06bc494ca11e Initial load
duke
parents:
diff changeset
   639
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   640
     *  @param t             The type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   641
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   642
    Type checkNullOrRefType(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   643
        switch (t.tag) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   644
        case CLASS:
06bc494ca11e Initial load
duke
parents:
diff changeset
   645
        case ARRAY:
06bc494ca11e Initial load
duke
parents:
diff changeset
   646
        case TYPEVAR:
06bc494ca11e Initial load
duke
parents:
diff changeset
   647
        case WILDCARD:
06bc494ca11e Initial load
duke
parents:
diff changeset
   648
        case BOT:
06bc494ca11e Initial load
duke
parents:
diff changeset
   649
        case ERROR:
06bc494ca11e Initial load
duke
parents:
diff changeset
   650
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   651
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   652
            return typeTagError(pos,
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
   653
                                diags.fragment("type.req.ref"),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   654
                                t);
06bc494ca11e Initial load
duke
parents:
diff changeset
   655
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   656
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   657
06bc494ca11e Initial load
duke
parents:
diff changeset
   658
    /** Check that flag set does not contain elements of two conflicting sets. s
06bc494ca11e Initial load
duke
parents:
diff changeset
   659
     *  Return true if it doesn't.
06bc494ca11e Initial load
duke
parents:
diff changeset
   660
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   661
     *  @param flags         The set of flags to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
   662
     *  @param set1          Conflicting flags set #1.
06bc494ca11e Initial load
duke
parents:
diff changeset
   663
     *  @param set2          Conflicting flags set #2.
06bc494ca11e Initial load
duke
parents:
diff changeset
   664
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   665
    boolean checkDisjoint(DiagnosticPosition pos, long flags, long set1, long set2) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   666
        if ((flags & set1) != 0 && (flags & set2) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   667
            log.error(pos,
06bc494ca11e Initial load
duke
parents:
diff changeset
   668
                      "illegal.combination.of.modifiers",
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
   669
                      asFlagSet(TreeInfo.firstFlag(flags & set1)),
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
   670
                      asFlagSet(TreeInfo.firstFlag(flags & set2)));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   671
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   672
        } else
06bc494ca11e Initial load
duke
parents:
diff changeset
   673
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   674
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   675
8635
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   676
    /** Check that usage of diamond operator is correct (i.e. diamond should not
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   677
     * be used with non-generic classes or in anonymous class creation expressions)
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   678
     */
8635
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   679
    Type checkDiamond(JCNewClass tree, Type t) {
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   680
        if (!TreeInfo.isDiamond(tree) ||
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   681
                t.isErroneous()) {
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   682
            return checkClassType(tree.clazz.pos(), t, true);
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   683
        } else if (tree.def != null) {
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   684
            log.error(tree.clazz.pos(),
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   685
                    "cant.apply.diamond.1",
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   686
                    t, diags.fragment("diamond.and.anon.class", t));
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   687
            return types.createErrorType(t);
9073
a29adf86aa0c 7030687: Diamond: compiler accepts erroneous code where diamond is used with non-generic inner class
mcimadamore
parents: 8635
diff changeset
   688
        } else if (t.tsym.type.getTypeArguments().isEmpty()) {
8635
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   689
            log.error(tree.clazz.pos(),
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   690
                "cant.apply.diamond.1",
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   691
                t, diags.fragment("diamond.non.generic", t));
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   692
            return types.createErrorType(t);
9604
d7152128d22f 7039931: Project Coin: diamond inference fail with generic constructor explicit type-arguments
mcimadamore
parents: 9303
diff changeset
   693
        } else if (tree.typeargs != null &&
d7152128d22f 7039931: Project Coin: diamond inference fail with generic constructor explicit type-arguments
mcimadamore
parents: 9303
diff changeset
   694
                tree.typeargs.nonEmpty()) {
d7152128d22f 7039931: Project Coin: diamond inference fail with generic constructor explicit type-arguments
mcimadamore
parents: 9303
diff changeset
   695
            log.error(tree.clazz.pos(),
d7152128d22f 7039931: Project Coin: diamond inference fail with generic constructor explicit type-arguments
mcimadamore
parents: 9303
diff changeset
   696
                "cant.apply.diamond.1",
d7152128d22f 7039931: Project Coin: diamond inference fail with generic constructor explicit type-arguments
mcimadamore
parents: 9303
diff changeset
   697
                t, diags.fragment("diamond.and.explicit.params", t));
d7152128d22f 7039931: Project Coin: diamond inference fail with generic constructor explicit type-arguments
mcimadamore
parents: 9303
diff changeset
   698
            return types.createErrorType(t);
8635
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   699
        } else {
383a416a2bdf 7020044: Project Coin: diamond erroneous allowed on some anonymous inner classes
mcimadamore
parents: 8628
diff changeset
   700
            return t;
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   701
        }
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   702
    }
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   703
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   704
    void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   705
        MethodSymbol m = tree.sym;
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   706
        if (!allowSimplifiedVarargs) return;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   707
        boolean hasTrustMeAnno = m.attribute(syms.trustMeType.tsym) != null;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   708
        Type varargElemType = null;
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   709
        if (m.isVarArgs()) {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   710
            varargElemType = types.elemtype(tree.params.last().type);
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   711
        }
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   712
        if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   713
            if (varargElemType != null) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   714
                log.error(tree,
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   715
                        "varargs.invalid.trustme.anno",
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   716
                        syms.trustMeType.tsym,
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   717
                        diags.fragment("varargs.trustme.on.virtual.varargs", m));
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   718
            } else {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   719
                log.error(tree,
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   720
                            "varargs.invalid.trustme.anno",
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   721
                            syms.trustMeType.tsym,
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   722
                            diags.fragment("varargs.trustme.on.non.varargs.meth", m));
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   723
            }
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   724
        } else if (hasTrustMeAnno && varargElemType != null &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   725
                            types.isReifiable(varargElemType)) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   726
            warnUnsafeVararg(tree,
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   727
                            "varargs.redundant.trustme.anno",
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   728
                            syms.trustMeType.tsym,
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   729
                            diags.fragment("varargs.trustme.on.reifiable.varargs", varargElemType));
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   730
        }
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   731
        else if (!hasTrustMeAnno && varargElemType != null &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   732
                !types.isReifiable(varargElemType)) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   733
            warnUnchecked(tree.params.head.pos(), "unchecked.varargs.non.reifiable.type", varargElemType);
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   734
        }
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   735
    }
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   736
    //where
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   737
        private boolean isTrustMeAllowedOnMethod(Symbol s) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   738
            return (s.flags() & VARARGS) != 0 &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   739
                (s.isConstructor() ||
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   740
                    (s.flags() & (STATIC | FINAL)) != 0);
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   741
        }
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   742
5489
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   743
    /**
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   744
     * Check that vararg method call is sound
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   745
     * @param pos Position to be used for error reporting.
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   746
     * @param argtypes Actual arguments supplied to vararg method.
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   747
     */
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   748
    void checkVararg(DiagnosticPosition pos, List<Type> argtypes, Symbol msym) {
5489
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   749
        Type argtype = argtypes.last();
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   750
        if (!types.isReifiable(argtype) &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   751
                (!allowSimplifiedVarargs ||
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   752
                msym.attribute(syms.trustMeType.tsym) == null ||
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
   753
                !isTrustMeAllowedOnMethod(msym))) {
5489
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   754
            warnUnchecked(pos,
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   755
                              "unchecked.generic.array.creation",
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   756
                              argtype);
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5842
diff changeset
   757
        }
5489
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   758
    }
e7af65bf7577 6730476: invalid "unchecked generic array" warning
mcimadamore
parents: 5321
diff changeset
   759
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   760
    /**
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   761
     * Check that type 't' is a valid instantiation of a generic class
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   762
     * (see JLS 4.5)
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   763
     *
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   764
     * @param t class type to be checked
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   765
     * @return true if 't' is well-formed
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   766
     */
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   767
    public boolean checkValidGenericType(Type t) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   768
        return firstIncompatibleTypeArg(t) == null;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   769
    }
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   770
    //WHERE
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   771
        private Type firstIncompatibleTypeArg(Type type) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   772
            List<Type> formals = type.tsym.type.allparams();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   773
            List<Type> actuals = type.allparams();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   774
            List<Type> args = type.getTypeArguments();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   775
            List<Type> forms = type.tsym.type.getTypeArguments();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   776
            ListBuffer<Type> tvars_buf = new ListBuffer<Type>();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   777
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   778
            // For matching pairs of actual argument types `a' and
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   779
            // formal type parameters with declared bound `b' ...
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   780
            while (args.nonEmpty() && forms.nonEmpty()) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   781
                // exact type arguments needs to know their
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   782
                // bounds (for upper and lower bound
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   783
                // calculations).  So we create new TypeVars with
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   784
                // bounds substed with actuals.
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   785
                tvars_buf.append(types.substBound(((TypeVar)forms.head),
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   786
                                                  formals,
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   787
                                                  actuals));
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   788
                args = args.tail;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   789
                forms = forms.tail;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   790
            }
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   791
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   792
            args = type.getTypeArguments();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   793
            List<Type> tvars_cap = types.substBounds(formals,
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   794
                                      formals,
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   795
                                      types.capture(type).allparams());
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   796
            while (args.nonEmpty() && tvars_cap.nonEmpty()) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   797
                // Let the actual arguments know their bound
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   798
                args.head.withTypeVar((TypeVar)tvars_cap.head);
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   799
                args = args.tail;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   800
                tvars_cap = tvars_cap.tail;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   801
            }
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   802
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   803
            args = type.getTypeArguments();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   804
            List<Type> tvars = tvars_buf.toList();
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   805
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   806
            while (args.nonEmpty() && tvars.nonEmpty()) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   807
                Type actual = types.subst(args.head,
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   808
                    type.tsym.type.getTypeArguments(),
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   809
                    tvars_buf.toList());
8238
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   810
                if (!isTypeArgErroneous(actual) &&
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   811
                        !tvars.head.getUpperBound().isErroneous() &&
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   812
                        !checkExtends(actual, (TypeVar)tvars.head)) {
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   813
                    return args.head;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   814
                }
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   815
                args = args.tail;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   816
                tvars = tvars.tail;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   817
            }
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   818
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   819
            args = type.getTypeArguments();
8044
7fd529d4472c 6943278: spurious error message for inference and type-variable with erroneous bound
mcimadamore
parents: 8037
diff changeset
   820
            tvars = tvars_buf.toList();
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   821
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   822
            for (Type arg : types.capture(type).getTypeArguments()) {
8044
7fd529d4472c 6943278: spurious error message for inference and type-variable with erroneous bound
mcimadamore
parents: 8037
diff changeset
   823
                if (arg.tag == TYPEVAR &&
7fd529d4472c 6943278: spurious error message for inference and type-variable with erroneous bound
mcimadamore
parents: 8037
diff changeset
   824
                        arg.getUpperBound().isErroneous() &&
8238
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   825
                        !tvars.head.getUpperBound().isErroneous() &&
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   826
                        !isTypeArgErroneous(args.head)) {
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   827
                    return args.head;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   828
                }
8044
7fd529d4472c 6943278: spurious error message for inference and type-variable with erroneous bound
mcimadamore
parents: 8037
diff changeset
   829
                tvars = tvars.tail;
8238
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   830
                args = args.tail;
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   831
            }
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   832
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   833
            return null;
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   834
        }
8238
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   835
        //where
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   836
        boolean isTypeArgErroneous(Type t) {
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   837
            return isTypeArgErroneous.visit(t);
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   838
        }
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   839
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   840
        Types.UnaryVisitor<Boolean> isTypeArgErroneous = new Types.UnaryVisitor<Boolean>() {
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   841
            public Boolean visitType(Type t, Void s) {
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   842
                return t.isErroneous();
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   843
            }
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   844
            @Override
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   845
            public Boolean visitTypeVar(TypeVar t, Void s) {
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   846
                return visit(t.getUpperBound());
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   847
            }
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   848
            @Override
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   849
            public Boolean visitCapturedType(CapturedType t, Void s) {
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   850
                return visit(t.getUpperBound()) ||
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   851
                        visit(t.getLowerBound());
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   852
            }
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   853
            @Override
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   854
            public Boolean visitWildcardType(WildcardType t, Void s) {
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   855
                return visit(t.type);
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   856
            }
15ff254ff5c2 6969184: poor error recovery after symbol not found
mcimadamore
parents: 8237
diff changeset
   857
        };
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
   858
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   859
    /** Check that given modifiers are legal for given symbol and
06bc494ca11e Initial load
duke
parents:
diff changeset
   860
     *  return modifiers together with any implicit modififiers for that symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   861
     *  Warning: we can't use flags() here since this method
06bc494ca11e Initial load
duke
parents:
diff changeset
   862
     *  is called during class enter, when flags() would cause a premature
06bc494ca11e Initial load
duke
parents:
diff changeset
   863
     *  completion.
06bc494ca11e Initial load
duke
parents:
diff changeset
   864
     *  @param pos           Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
   865
     *  @param flags         The set of modifiers given in a definition.
06bc494ca11e Initial load
duke
parents:
diff changeset
   866
     *  @param sym           The defined symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
   867
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   868
    long checkFlags(DiagnosticPosition pos, long flags, Symbol sym, JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   869
        long mask;
06bc494ca11e Initial load
duke
parents:
diff changeset
   870
        long implicit = 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   871
        switch (sym.kind) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   872
        case VAR:
06bc494ca11e Initial load
duke
parents:
diff changeset
   873
            if (sym.owner.kind != TYP)
06bc494ca11e Initial load
duke
parents:
diff changeset
   874
                mask = LocalVarFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   875
            else if ((sym.owner.flags_field & INTERFACE) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   876
                mask = implicit = InterfaceVarFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   877
            else
06bc494ca11e Initial load
duke
parents:
diff changeset
   878
                mask = VarFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   879
            break;
06bc494ca11e Initial load
duke
parents:
diff changeset
   880
        case MTH:
06bc494ca11e Initial load
duke
parents:
diff changeset
   881
            if (sym.name == names.init) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   882
                if ((sym.owner.flags_field & ENUM) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   883
                    // enum constructors cannot be declared public or
06bc494ca11e Initial load
duke
parents:
diff changeset
   884
                    // protected and must be implicitly or explicitly
06bc494ca11e Initial load
duke
parents:
diff changeset
   885
                    // private
06bc494ca11e Initial load
duke
parents:
diff changeset
   886
                    implicit = PRIVATE;
06bc494ca11e Initial load
duke
parents:
diff changeset
   887
                    mask = PRIVATE;
06bc494ca11e Initial load
duke
parents:
diff changeset
   888
                } else
06bc494ca11e Initial load
duke
parents:
diff changeset
   889
                    mask = ConstructorFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   890
            }  else if ((sym.owner.flags_field & INTERFACE) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   891
                mask = implicit = InterfaceMethodFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   892
            else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   893
                mask = MethodFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   894
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   895
            // Imply STRICTFP if owner has STRICTFP set.
06bc494ca11e Initial load
duke
parents:
diff changeset
   896
            if (((flags|implicit) & Flags.ABSTRACT) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   897
              implicit |= sym.owner.flags_field & STRICTFP;
06bc494ca11e Initial load
duke
parents:
diff changeset
   898
            break;
06bc494ca11e Initial load
duke
parents:
diff changeset
   899
        case TYP:
06bc494ca11e Initial load
duke
parents:
diff changeset
   900
            if (sym.isLocal()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   901
                mask = LocalClassFlags;
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1257
diff changeset
   902
                if (sym.name.isEmpty()) { // Anonymous class
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   903
                    // Anonymous classes in static methods are themselves static;
06bc494ca11e Initial load
duke
parents:
diff changeset
   904
                    // that's why we admit STATIC here.
06bc494ca11e Initial load
duke
parents:
diff changeset
   905
                    mask |= STATIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
   906
                    // JLS: Anonymous classes are final.
06bc494ca11e Initial load
duke
parents:
diff changeset
   907
                    implicit |= FINAL;
06bc494ca11e Initial load
duke
parents:
diff changeset
   908
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   909
                if ((sym.owner.flags_field & STATIC) == 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   910
                    (flags & ENUM) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   911
                    log.error(pos, "enums.must.be.static");
06bc494ca11e Initial load
duke
parents:
diff changeset
   912
            } else if (sym.owner.kind == TYP) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   913
                mask = MemberClassFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   914
                if (sym.owner.owner.kind == PCK ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   915
                    (sym.owner.flags_field & STATIC) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   916
                    mask |= STATIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
   917
                else if ((flags & ENUM) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   918
                    log.error(pos, "enums.must.be.static");
06bc494ca11e Initial load
duke
parents:
diff changeset
   919
                // Nested interfaces and enums are always STATIC (Spec ???)
06bc494ca11e Initial load
duke
parents:
diff changeset
   920
                if ((flags & (INTERFACE | ENUM)) != 0 ) implicit = STATIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
   921
            } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   922
                mask = ClassFlags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   923
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   924
            // Interfaces are always ABSTRACT
06bc494ca11e Initial load
duke
parents:
diff changeset
   925
            if ((flags & INTERFACE) != 0) implicit |= ABSTRACT;
06bc494ca11e Initial load
duke
parents:
diff changeset
   926
06bc494ca11e Initial load
duke
parents:
diff changeset
   927
            if ((flags & ENUM) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   928
                // enums can't be declared abstract or final
06bc494ca11e Initial load
duke
parents:
diff changeset
   929
                mask &= ~(ABSTRACT | FINAL);
06bc494ca11e Initial load
duke
parents:
diff changeset
   930
                implicit |= implicitEnumFinalFlag(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   931
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   932
            // Imply STRICTFP if owner has STRICTFP set.
06bc494ca11e Initial load
duke
parents:
diff changeset
   933
            implicit |= sym.owner.flags_field & STRICTFP;
06bc494ca11e Initial load
duke
parents:
diff changeset
   934
            break;
06bc494ca11e Initial load
duke
parents:
diff changeset
   935
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   936
            throw new AssertionError();
06bc494ca11e Initial load
duke
parents:
diff changeset
   937
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   938
        long illegal = flags & StandardFlags & ~mask;
06bc494ca11e Initial load
duke
parents:
diff changeset
   939
        if (illegal != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   940
            if ((illegal & INTERFACE) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   941
                log.error(pos, "intf.not.allowed.here");
06bc494ca11e Initial load
duke
parents:
diff changeset
   942
                mask |= INTERFACE;
06bc494ca11e Initial load
duke
parents:
diff changeset
   943
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   944
            else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   945
                log.error(pos,
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
   946
                          "mod.not.allowed.here", asFlagSet(illegal));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   947
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   948
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   949
        else if ((sym.kind == TYP ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   950
                  // ISSUE: Disallowing abstract&private is no longer appropriate
06bc494ca11e Initial load
duke
parents:
diff changeset
   951
                  // in the presence of inner classes. Should it be deleted here?
06bc494ca11e Initial load
duke
parents:
diff changeset
   952
                  checkDisjoint(pos, flags,
06bc494ca11e Initial load
duke
parents:
diff changeset
   953
                                ABSTRACT,
06bc494ca11e Initial load
duke
parents:
diff changeset
   954
                                PRIVATE | STATIC))
06bc494ca11e Initial load
duke
parents:
diff changeset
   955
                 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   956
                 checkDisjoint(pos, flags,
06bc494ca11e Initial load
duke
parents:
diff changeset
   957
                               ABSTRACT | INTERFACE,
06bc494ca11e Initial load
duke
parents:
diff changeset
   958
                               FINAL | NATIVE | SYNCHRONIZED)
06bc494ca11e Initial load
duke
parents:
diff changeset
   959
                 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   960
                 checkDisjoint(pos, flags,
06bc494ca11e Initial load
duke
parents:
diff changeset
   961
                               PUBLIC,
06bc494ca11e Initial load
duke
parents:
diff changeset
   962
                               PRIVATE | PROTECTED)
06bc494ca11e Initial load
duke
parents:
diff changeset
   963
                 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   964
                 checkDisjoint(pos, flags,
06bc494ca11e Initial load
duke
parents:
diff changeset
   965
                               PRIVATE,
06bc494ca11e Initial load
duke
parents:
diff changeset
   966
                               PUBLIC | PROTECTED)
06bc494ca11e Initial load
duke
parents:
diff changeset
   967
                 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   968
                 checkDisjoint(pos, flags,
06bc494ca11e Initial load
duke
parents:
diff changeset
   969
                               FINAL,
06bc494ca11e Initial load
duke
parents:
diff changeset
   970
                               VOLATILE)
06bc494ca11e Initial load
duke
parents:
diff changeset
   971
                 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   972
                 (sym.kind == TYP ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   973
                  checkDisjoint(pos, flags,
06bc494ca11e Initial load
duke
parents:
diff changeset
   974
                                ABSTRACT | NATIVE,
06bc494ca11e Initial load
duke
parents:
diff changeset
   975
                                STRICTFP))) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   976
            // skip
06bc494ca11e Initial load
duke
parents:
diff changeset
   977
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   978
        return flags & (mask | ~StandardFlags) | implicit;
06bc494ca11e Initial load
duke
parents:
diff changeset
   979
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   980
06bc494ca11e Initial load
duke
parents:
diff changeset
   981
06bc494ca11e Initial load
duke
parents:
diff changeset
   982
    /** Determine if this enum should be implicitly final.
06bc494ca11e Initial load
duke
parents:
diff changeset
   983
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   984
     *  If the enum has no specialized enum contants, it is final.
06bc494ca11e Initial load
duke
parents:
diff changeset
   985
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   986
     *  If the enum does have specialized enum contants, it is
06bc494ca11e Initial load
duke
parents:
diff changeset
   987
     *  <i>not</i> final.
06bc494ca11e Initial load
duke
parents:
diff changeset
   988
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   989
    private long implicitEnumFinalFlag(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   990
        if (tree.getTag() != JCTree.CLASSDEF) return 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   991
        class SpecialTreeVisitor extends JCTree.Visitor {
06bc494ca11e Initial load
duke
parents:
diff changeset
   992
            boolean specialized;
06bc494ca11e Initial load
duke
parents:
diff changeset
   993
            SpecialTreeVisitor() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   994
                this.specialized = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   995
            };
06bc494ca11e Initial load
duke
parents:
diff changeset
   996
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
   997
            @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   998
            public void visitTree(JCTree tree) { /* no-op */ }
06bc494ca11e Initial load
duke
parents:
diff changeset
   999
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1000
            @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1001
            public void visitVarDef(JCVariableDecl tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1002
                if ((tree.mods.flags & ENUM) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1003
                    if (tree.init instanceof JCNewClass &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1004
                        ((JCNewClass) tree.init).def != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1005
                        specialized = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1006
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1007
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1008
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1009
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1010
06bc494ca11e Initial load
duke
parents:
diff changeset
  1011
        SpecialTreeVisitor sts = new SpecialTreeVisitor();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1012
        JCClassDecl cdef = (JCClassDecl) tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1013
        for (JCTree defs: cdef.defs) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1014
            defs.accept(sts);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1015
            if (sts.specialized) return 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1016
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1017
        return FINAL;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1018
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1019
06bc494ca11e Initial load
duke
parents:
diff changeset
  1020
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  1021
 * Type Validation
06bc494ca11e Initial load
duke
parents:
diff changeset
  1022
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  1023
06bc494ca11e Initial load
duke
parents:
diff changeset
  1024
    /** Validate a type expression. That is,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1025
     *  check that all type arguments of a parametric type are within
06bc494ca11e Initial load
duke
parents:
diff changeset
  1026
     *  their bounds. This must be done in a second phase after type attributon
06bc494ca11e Initial load
duke
parents:
diff changeset
  1027
     *  since a class might have a subclass as type parameter bound. E.g:
06bc494ca11e Initial load
duke
parents:
diff changeset
  1028
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1029
     *  class B<A extends C> { ... }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1030
     *  class C extends B<C> { ... }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1031
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1032
     *  and we can't make sure that the bound is already attributed because
06bc494ca11e Initial load
duke
parents:
diff changeset
  1033
     *  of possible cycles.
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1034
     *
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1035
     * Visitor method: Validate a type expression, if it is not null, catching
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1036
     *  and reporting any completion failures.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1037
     */
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1038
    void validate(JCTree tree, Env<AttrContext> env) {
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1039
        validate(tree, env, true);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1040
    }
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1041
    void validate(JCTree tree, Env<AttrContext> env, boolean checkRaw) {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1042
        new Validator(env).validateTree(tree, checkRaw, true);
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1043
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1044
06bc494ca11e Initial load
duke
parents:
diff changeset
  1045
    /** Visitor method: Validate a list of type expressions.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1046
     */
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1047
    void validate(List<? extends JCTree> trees, Env<AttrContext> env) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1048
        for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1049
            validate(l.head, env);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1050
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1051
06bc494ca11e Initial load
duke
parents:
diff changeset
  1052
    /** A visitor class for type validation.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1053
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1054
    class Validator extends JCTree.Visitor {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1055
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1056
        boolean isOuter;
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1057
        Env<AttrContext> env;
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1058
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1059
        Validator(Env<AttrContext> env) {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1060
            this.env = env;
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1061
        }
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1062
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1063
        @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1064
        public void visitTypeArray(JCArrayTypeTree tree) {
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1065
            tree.elemtype.accept(this);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1066
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1067
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1068
        @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1069
        public void visitTypeApply(JCTypeApply tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1070
            if (tree.type.tag == CLASS) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1071
                List<JCExpression> args = tree.arguments;
1531
37df4e42719a 6557954: Inner class type parameters doesn't get substituted when checking type well-formedness
mcimadamore
parents: 1527
diff changeset
  1072
                List<Type> forms = tree.type.tsym.type.getTypeArguments();
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
  1073
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
  1074
                Type incompatibleArg = firstIncompatibleTypeArg(tree.type);
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
  1075
                if (incompatibleArg != null) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
  1076
                    for (JCTree arg : tree.arguments) {
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
  1077
                        if (arg.type == incompatibleArg) {
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8044
diff changeset
  1078
                            log.error(arg, "not.within.bounds", incompatibleArg, forms.head);
8037
b3f278fe95d6 7007432: Test generic types well-formedness
mcimadamore
parents: 8032
diff changeset
  1079
                        }
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8044
diff changeset
  1080
                        forms = forms.tail;
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8044
diff changeset
  1081
                     }
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8044
diff changeset
  1082
                 }
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8044
diff changeset
  1083
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8044
diff changeset
  1084
                forms = tree.type.tsym.type.getTypeArguments();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1085
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1086
                boolean is_java_lang_Class = tree.type.tsym.flatName() == names.java_lang_Class;
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1087
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1088
                // For matching pairs of actual argument types `a' and
06bc494ca11e Initial load
duke
parents:
diff changeset
  1089
                // formal type parameters with declared bound `b' ...
06bc494ca11e Initial load
duke
parents:
diff changeset
  1090
                while (args.nonEmpty() && forms.nonEmpty()) {
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1091
                    validateTree(args.head,
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1092
                            !(isOuter && is_java_lang_Class),
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1093
                            false);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1094
                    args = args.tail;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1095
                    forms = forms.tail;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1096
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1097
06bc494ca11e Initial load
duke
parents:
diff changeset
  1098
                // Check that this type is either fully parameterized, or
06bc494ca11e Initial load
duke
parents:
diff changeset
  1099
                // not parameterized at all.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1100
                if (tree.type.getEnclosingType().isRaw())
06bc494ca11e Initial load
duke
parents:
diff changeset
  1101
                    log.error(tree.pos(), "improperly.formed.type.inner.raw.param");
06bc494ca11e Initial load
duke
parents:
diff changeset
  1102
                if (tree.clazz.getTag() == JCTree.SELECT)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1103
                    visitSelectInternal((JCFieldAccess)tree.clazz);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1104
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1105
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1106
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1107
        @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1108
        public void visitTypeParameter(JCTypeParameter tree) {
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1109
            validateTrees(tree.bounds, true, isOuter);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1110
            checkClassBounds(tree.pos(), tree.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1111
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1112
06bc494ca11e Initial load
duke
parents:
diff changeset
  1113
        @Override
06bc494ca11e Initial load
duke
parents:
diff changeset
  1114
        public void visitWildcard(JCWildcard tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1115
            if (tree.inner != null)
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1116
                validateTree(tree.inner, true, isOuter);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1117
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1118
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1119
        @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1120
        public void visitSelect(JCFieldAccess tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1121
            if (tree.type.tag == CLASS) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1122
                visitSelectInternal(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1123
06bc494ca11e Initial load
duke
parents:
diff changeset
  1124
                // Check that this type is either fully parameterized, or
06bc494ca11e Initial load
duke
parents:
diff changeset
  1125
                // not parameterized at all.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1126
                if (tree.selected.type.isParameterized() && tree.type.tsym.type.getTypeArguments().nonEmpty())
06bc494ca11e Initial load
duke
parents:
diff changeset
  1127
                    log.error(tree.pos(), "improperly.formed.type.param.missing");
06bc494ca11e Initial load
duke
parents:
diff changeset
  1128
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1129
        }
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  1130
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1131
        public void visitSelectInternal(JCFieldAccess tree) {
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1132
            if (tree.type.tsym.isStatic() &&
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1133
                tree.selected.type.isParameterized()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1134
                // The enclosing type is not a class, so we are
06bc494ca11e Initial load
duke
parents:
diff changeset
  1135
                // looking at a static member type.  However, the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1136
                // qualifying expression is parameterized.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1137
                log.error(tree.pos(), "cant.select.static.class.from.param.type");
06bc494ca11e Initial load
duke
parents:
diff changeset
  1138
            } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1139
                // otherwise validate the rest of the expression
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1140
                tree.selected.accept(this);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1141
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1142
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1143
06bc494ca11e Initial load
duke
parents:
diff changeset
  1144
        /** Default visitor method: do nothing.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1145
         */
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1146
        @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1147
        public void visitTree(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1148
        }
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1260
diff changeset
  1149
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1150
        public void validateTree(JCTree tree, boolean checkRaw, boolean isOuter) {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1151
            try {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1152
                if (tree != null) {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1153
                    this.isOuter = isOuter;
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1154
                    tree.accept(this);
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1155
                    if (checkRaw)
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1156
                        checkRaw(tree, env);
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1157
                }
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1158
            } catch (CompletionFailure ex) {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1159
                completionError(tree.pos(), ex);
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1160
            }
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1161
        }
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1162
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1163
        public void validateTrees(List<? extends JCTree> trees, boolean checkRaw, boolean isOuter) {
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1164
            for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1165
                validateTree(l.head, checkRaw, isOuter);
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1166
        }
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1167
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1168
        void checkRaw(JCTree tree, Env<AttrContext> env) {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  1169
            if (lint.isEnabled(LintCategory.RAW) &&
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1170
                tree.type.tag == CLASS &&
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1171
                !TreeInfo.isDiamond(tree) &&
10721
ca322e50ddb7 7090499: missing rawtypes warnings in anonymous inner class
mcimadamore
parents: 10626
diff changeset
  1172
                !withinAnonConstr(env) &&
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1173
                tree.type.isRaw()) {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  1174
                log.warning(LintCategory.RAW,
6351
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1175
                        tree.pos(), "raw.class.use", tree.type, tree.type.tsym.type);
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1176
            }
84c44db80d06 6885255: Improve usability of raw warnings
mcimadamore
parents: 6347
diff changeset
  1177
        }
10721
ca322e50ddb7 7090499: missing rawtypes warnings in anonymous inner class
mcimadamore
parents: 10626
diff changeset
  1178
ca322e50ddb7 7090499: missing rawtypes warnings in anonymous inner class
mcimadamore
parents: 10626
diff changeset
  1179
        boolean withinAnonConstr(Env<AttrContext> env) {
ca322e50ddb7 7090499: missing rawtypes warnings in anonymous inner class
mcimadamore
parents: 10626
diff changeset
  1180
            return env.enclClass.name.isEmpty() &&
ca322e50ddb7 7090499: missing rawtypes warnings in anonymous inner class
mcimadamore
parents: 10626
diff changeset
  1181
                    env.enclMethod != null && env.enclMethod.name == names.init;
ca322e50ddb7 7090499: missing rawtypes warnings in anonymous inner class
mcimadamore
parents: 10626
diff changeset
  1182
        }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1183
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1184
06bc494ca11e Initial load
duke
parents:
diff changeset
  1185
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  1186
 * Exception checking
06bc494ca11e Initial load
duke
parents:
diff changeset
  1187
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  1188
06bc494ca11e Initial load
duke
parents:
diff changeset
  1189
    /* The following methods treat classes as sets that contain
06bc494ca11e Initial load
duke
parents:
diff changeset
  1190
     * the class itself and all their subclasses
06bc494ca11e Initial load
duke
parents:
diff changeset
  1191
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1192
06bc494ca11e Initial load
duke
parents:
diff changeset
  1193
    /** Is given type a subtype of some of the types in given list?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1194
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1195
    boolean subset(Type t, List<Type> ts) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1196
        for (List<Type> l = ts; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1197
            if (types.isSubtype(t, l.head)) return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1198
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1199
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1200
06bc494ca11e Initial load
duke
parents:
diff changeset
  1201
    /** Is given type a subtype or supertype of
06bc494ca11e Initial load
duke
parents:
diff changeset
  1202
     *  some of the types in given list?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1203
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1204
    boolean intersects(Type t, List<Type> ts) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1205
        for (List<Type> l = ts; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1206
            if (types.isSubtype(t, l.head) || types.isSubtype(l.head, t)) return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1207
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1208
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1209
06bc494ca11e Initial load
duke
parents:
diff changeset
  1210
    /** Add type set to given type list, unless it is a subclass of some class
06bc494ca11e Initial load
duke
parents:
diff changeset
  1211
     *  in the list.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1212
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1213
    List<Type> incl(Type t, List<Type> ts) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1214
        return subset(t, ts) ? ts : excl(t, ts).prepend(t);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1215
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1216
06bc494ca11e Initial load
duke
parents:
diff changeset
  1217
    /** Remove type set from type set list.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1218
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1219
    List<Type> excl(Type t, List<Type> ts) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1220
        if (ts.isEmpty()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1221
            return ts;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1222
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1223
            List<Type> ts1 = excl(t, ts.tail);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1224
            if (types.isSubtype(ts.head, t)) return ts1;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1225
            else if (ts1 == ts.tail) return ts;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1226
            else return ts1.prepend(ts.head);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1227
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1228
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1229
06bc494ca11e Initial load
duke
parents:
diff changeset
  1230
    /** Form the union of two type set lists.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1231
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1232
    List<Type> union(List<Type> ts1, List<Type> ts2) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1233
        List<Type> ts = ts1;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1234
        for (List<Type> l = ts2; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1235
            ts = incl(l.head, ts);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1236
        return ts;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1237
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1238
06bc494ca11e Initial load
duke
parents:
diff changeset
  1239
    /** Form the difference of two type lists.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1240
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1241
    List<Type> diff(List<Type> ts1, List<Type> ts2) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1242
        List<Type> ts = ts1;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1243
        for (List<Type> l = ts2; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1244
            ts = excl(l.head, ts);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1245
        return ts;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1246
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1247
06bc494ca11e Initial load
duke
parents:
diff changeset
  1248
    /** Form the intersection of two type lists.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1249
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1250
    public List<Type> intersect(List<Type> ts1, List<Type> ts2) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1251
        List<Type> ts = List.nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1252
        for (List<Type> l = ts1; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1253
            if (subset(l.head, ts2)) ts = incl(l.head, ts);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1254
        for (List<Type> l = ts2; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1255
            if (subset(l.head, ts1)) ts = incl(l.head, ts);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1256
        return ts;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1257
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1258
06bc494ca11e Initial load
duke
parents:
diff changeset
  1259
    /** Is exc an exception symbol that need not be declared?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1260
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1261
    boolean isUnchecked(ClassSymbol exc) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1262
        return
06bc494ca11e Initial load
duke
parents:
diff changeset
  1263
            exc.kind == ERR ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1264
            exc.isSubClass(syms.errorType.tsym, types) ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1265
            exc.isSubClass(syms.runtimeExceptionType.tsym, types);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1266
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1267
06bc494ca11e Initial load
duke
parents:
diff changeset
  1268
    /** Is exc an exception type that need not be declared?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1269
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1270
    boolean isUnchecked(Type exc) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1271
        return
06bc494ca11e Initial load
duke
parents:
diff changeset
  1272
            (exc.tag == TYPEVAR) ? isUnchecked(types.supertype(exc)) :
06bc494ca11e Initial load
duke
parents:
diff changeset
  1273
            (exc.tag == CLASS) ? isUnchecked((ClassSymbol)exc.tsym) :
06bc494ca11e Initial load
duke
parents:
diff changeset
  1274
            exc.tag == BOT;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1275
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1276
06bc494ca11e Initial load
duke
parents:
diff changeset
  1277
    /** Same, but handling completion failures.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1278
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1279
    boolean isUnchecked(DiagnosticPosition pos, Type exc) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1280
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1281
            return isUnchecked(exc);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1282
        } catch (CompletionFailure ex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1283
            completionError(pos, ex);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1284
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1285
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1286
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1287
06bc494ca11e Initial load
duke
parents:
diff changeset
  1288
    /** Is exc handled by given exception list?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1289
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1290
    boolean isHandled(Type exc, List<Type> handled) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1291
        return isUnchecked(exc) || subset(exc, handled);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1292
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1293
06bc494ca11e Initial load
duke
parents:
diff changeset
  1294
    /** Return all exceptions in thrown list that are not in handled list.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1295
     *  @param thrown     The list of thrown exceptions.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1296
     *  @param handled    The list of handled exceptions.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1297
     */
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1298
    List<Type> unhandled(List<Type> thrown, List<Type> handled) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1299
        List<Type> unhandled = List.nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1300
        for (List<Type> l = thrown; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1301
            if (!isHandled(l.head, handled)) unhandled = unhandled.prepend(l.head);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1302
        return unhandled;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1303
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1304
06bc494ca11e Initial load
duke
parents:
diff changeset
  1305
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  1306
 * Overriding/Implementation checking
06bc494ca11e Initial load
duke
parents:
diff changeset
  1307
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  1308
06bc494ca11e Initial load
duke
parents:
diff changeset
  1309
    /** The level of access protection given by a flag set,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1310
     *  where PRIVATE is highest and PUBLIC is lowest.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1311
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1312
    static int protection(long flags) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1313
        switch ((short)(flags & AccessFlags)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1314
        case PRIVATE: return 3;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1315
        case PROTECTED: return 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1316
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
  1317
        case PUBLIC: return 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1318
        case 0: return 2;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1319
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1320
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1321
06bc494ca11e Initial load
duke
parents:
diff changeset
  1322
    /** A customized "cannot override" error message.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1323
     *  @param m      The overriding method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1324
     *  @param other  The overridden method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1325
     *  @return       An internationalized string.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1326
     */
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
  1327
    Object cannotOverride(MethodSymbol m, MethodSymbol other) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1328
        String key;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1329
        if ((other.owner.flags() & INTERFACE) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1330
            key = "cant.override";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1331
        else if ((m.owner.flags() & INTERFACE) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1332
            key = "cant.implement";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1333
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
  1334
            key = "clashes.with";
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
  1335
        return diags.fragment(key, m, m.location(), other, other.location());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1336
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1337
06bc494ca11e Initial load
duke
parents:
diff changeset
  1338
    /** A customized "override" warning message.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1339
     *  @param m      The overriding method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1340
     *  @param other  The overridden method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1341
     *  @return       An internationalized string.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1342
     */
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
  1343
    Object uncheckedOverrides(MethodSymbol m, MethodSymbol other) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1344
        String key;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1345
        if ((other.owner.flags() & INTERFACE) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1346
            key = "unchecked.override";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1347
        else if ((m.owner.flags() & INTERFACE) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1348
            key = "unchecked.implement";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1349
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
  1350
            key = "unchecked.clash.with";
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
  1351
        return diags.fragment(key, m, m.location(), other, other.location());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1352
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1353
06bc494ca11e Initial load
duke
parents:
diff changeset
  1354
    /** A customized "override" warning message.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1355
     *  @param m      The overriding method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1356
     *  @param other  The overridden method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1357
     *  @return       An internationalized string.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1358
     */
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
  1359
    Object varargsOverrides(MethodSymbol m, MethodSymbol other) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1360
        String key;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1361
        if ((other.owner.flags() & INTERFACE) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1362
            key = "varargs.override";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1363
        else  if ((m.owner.flags() & INTERFACE) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1364
            key = "varargs.implement";
06bc494ca11e Initial load
duke
parents:
diff changeset
  1365
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
  1366
            key = "varargs.clash.with";
1040
c0f5acfd9d15 6730423: Diagnostic formatter should be an instance field of JCDiagnostic
mcimadamore
parents: 939
diff changeset
  1367
        return diags.fragment(key, m, m.location(), other, other.location());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1368
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1369
06bc494ca11e Initial load
duke
parents:
diff changeset
  1370
    /** Check that this method conforms with overridden method 'other'.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1371
     *  where `origin' is the class where checking started.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1372
     *  Complications:
06bc494ca11e Initial load
duke
parents:
diff changeset
  1373
     *  (1) Do not check overriding of synthetic methods
06bc494ca11e Initial load
duke
parents:
diff changeset
  1374
     *      (reason: they might be final).
06bc494ca11e Initial load
duke
parents:
diff changeset
  1375
     *      todo: check whether this is still necessary.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1376
     *  (2) Admit the case where an interface proxy throws fewer exceptions
06bc494ca11e Initial load
duke
parents:
diff changeset
  1377
     *      than the method it implements. Augment the proxy methods with the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1378
     *      undeclared exceptions in this case.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1379
     *  (3) When generics are enabled, admit the case where an interface proxy
06bc494ca11e Initial load
duke
parents:
diff changeset
  1380
     *      has a result type
06bc494ca11e Initial load
duke
parents:
diff changeset
  1381
     *      extended by the result type of the method it implements.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1382
     *      Change the proxies result type to the smaller type in this case.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1383
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1384
     *  @param tree         The tree from which positions
06bc494ca11e Initial load
duke
parents:
diff changeset
  1385
     *                      are extracted for errors.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1386
     *  @param m            The overriding method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1387
     *  @param other        The overridden method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1388
     *  @param origin       The class of which the overriding method
06bc494ca11e Initial load
duke
parents:
diff changeset
  1389
     *                      is a member.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1390
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1391
    void checkOverride(JCTree tree,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1392
                       MethodSymbol m,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1393
                       MethodSymbol other,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1394
                       ClassSymbol origin) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1395
        // Don't check overriding of synthetic methods or by bridge methods.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1396
        if ((m.flags() & (SYNTHETIC|BRIDGE)) != 0 || (other.flags() & SYNTHETIC) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1397
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1398
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1399
06bc494ca11e Initial load
duke
parents:
diff changeset
  1400
        // Error if static method overrides instance method (JLS 8.4.6.2).
06bc494ca11e Initial load
duke
parents:
diff changeset
  1401
        if ((m.flags() & STATIC) != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1402
                   (other.flags() & STATIC) == 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1403
            log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.static",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1404
                      cannotOverride(m, other));
06bc494ca11e Initial load
duke
parents:
diff changeset
  1405
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1406
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1407
06bc494ca11e Initial load
duke
parents:
diff changeset
  1408
        // Error if instance method overrides static or final
06bc494ca11e Initial load
duke
parents:
diff changeset
  1409
        // method (JLS 8.4.6.1).
06bc494ca11e Initial load
duke
parents:
diff changeset
  1410
        if ((other.flags() & FINAL) != 0 ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1411
                 (m.flags() & STATIC) == 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1412
                 (other.flags() & STATIC) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1413
            log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.meth",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1414
                      cannotOverride(m, other),
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
  1415
                      asFlagSet(other.flags() & (FINAL | STATIC)));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1416
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1417
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1418
06bc494ca11e Initial load
duke
parents:
diff changeset
  1419
        if ((m.owner.flags() & ANNOTATION) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1420
            // handled in validateAnnotationMethod
06bc494ca11e Initial load
duke
parents:
diff changeset
  1421
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1422
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1423
06bc494ca11e Initial load
duke
parents:
diff changeset
  1424
        // Error if overriding method has weaker access (JLS 8.4.6.3).
06bc494ca11e Initial load
duke
parents:
diff changeset
  1425
        if ((origin.flags() & INTERFACE) == 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1426
                 protection(m.flags()) > protection(other.flags())) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1427
            log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.weaker.access",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1428
                      cannotOverride(m, other),
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
  1429
                      other.flags() == 0 ?
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
  1430
                          Flag.PACKAGE :
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 938
diff changeset
  1431
                          asFlagSet(other.flags() & AccessFlags));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1432
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1433
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1434
06bc494ca11e Initial load
duke
parents:
diff changeset
  1435
        Type mt = types.memberType(origin.type, m);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1436
        Type ot = types.memberType(origin.type, other);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1437
        // Error if overriding result type is different
06bc494ca11e Initial load
duke
parents:
diff changeset
  1438
        // (or, in the case of generics mode, not a subtype) of
06bc494ca11e Initial load
duke
parents:
diff changeset
  1439
        // overridden result type. We have to rename any type parameters
06bc494ca11e Initial load
duke
parents:
diff changeset
  1440
        // before comparing types.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1441
        List<Type> mtvars = mt.getTypeArguments();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1442
        List<Type> otvars = ot.getTypeArguments();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1443
        Type mtres = mt.getReturnType();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1444
        Type otres = types.subst(ot.getReturnType(), otvars, mtvars);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1445
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  1446
        overrideWarner.clear();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1447
        boolean resultTypesOK =
1874
891c2d6823bb 6797463: 6557199 breaks the jax-ws workspace
tbell
parents: 1868
diff changeset
  1448
            types.returnTypeSubstitutable(mt, ot, otres, overrideWarner);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1449
        if (!resultTypesOK) {
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  1450
            if (!allowCovariantReturns &&
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1451
                m.owner != origin &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1452
                m.owner.isSubClass(other.owner, types)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1453
                // allow limited interoperability with covariant returns
06bc494ca11e Initial load
duke
parents:
diff changeset
  1454
            } else {
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1455
                log.error(TreeInfo.diagnosticPositionFor(m, tree),
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1456
                          "override.incompatible.ret",
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1457
                          cannotOverride(m, other),
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1458
                          mtres, otres);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1459
                return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1460
            }
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  1461
        } else if (overrideWarner.hasNonSilentLint(LintCategory.UNCHECKED)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1462
            warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree),
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1463
                    "override.unchecked.ret",
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1464
                    uncheckedOverrides(m, other),
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1465
                    mtres, otres);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1466
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1467
06bc494ca11e Initial load
duke
parents:
diff changeset
  1468
        // Error if overriding method throws an exception not reported
06bc494ca11e Initial load
duke
parents:
diff changeset
  1469
        // by overridden method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1470
        List<Type> otthrown = types.subst(ot.getThrownTypes(), otvars, mtvars);
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1471
        List<Type> unhandledErased = unhandled(mt.getThrownTypes(), types.erasure(otthrown));
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1472
        List<Type> unhandledUnerased = unhandled(mt.getThrownTypes(), otthrown);
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1473
        if (unhandledErased.nonEmpty()) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1474
            log.error(TreeInfo.diagnosticPositionFor(m, tree),
06bc494ca11e Initial load
duke
parents:
diff changeset
  1475
                      "override.meth.doesnt.throw",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1476
                      cannotOverride(m, other),
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1477
                      unhandledUnerased.head);
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1478
            return;
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1479
        }
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1480
        else if (unhandledUnerased.nonEmpty()) {
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1481
            warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree),
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1482
                          "override.unchecked.thrown",
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1483
                         cannotOverride(m, other),
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1484
                         unhandledUnerased.head);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1485
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1486
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1487
06bc494ca11e Initial load
duke
parents:
diff changeset
  1488
        // Optional warning if varargs don't agree
06bc494ca11e Initial load
duke
parents:
diff changeset
  1489
        if ((((m.flags() ^ other.flags()) & Flags.VARARGS) != 0)
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  1490
            && lint.isEnabled(LintCategory.OVERRIDES)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1491
            log.warning(TreeInfo.diagnosticPositionFor(m, tree),
06bc494ca11e Initial load
duke
parents:
diff changeset
  1492
                        ((m.flags() & Flags.VARARGS) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1493
                        ? "override.varargs.missing"
06bc494ca11e Initial load
duke
parents:
diff changeset
  1494
                        : "override.varargs.extra",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1495
                        varargsOverrides(m, other));
06bc494ca11e Initial load
duke
parents:
diff changeset
  1496
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1497
06bc494ca11e Initial load
duke
parents:
diff changeset
  1498
        // Warn if instance method overrides bridge method (compiler spec ??)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1499
        if ((other.flags() & BRIDGE) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1500
            log.warning(TreeInfo.diagnosticPositionFor(m, tree), "override.bridge",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1501
                        uncheckedOverrides(m, other));
06bc494ca11e Initial load
duke
parents:
diff changeset
  1502
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1503
06bc494ca11e Initial load
duke
parents:
diff changeset
  1504
        // Warn if a deprecated method overridden by a non-deprecated one.
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  1505
        if (!isDeprecatedOverrideIgnorable(other, origin)) {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  1506
            checkDeprecated(TreeInfo.diagnosticPositionFor(m, tree), m, other);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1507
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1508
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1509
    // where
06bc494ca11e Initial load
duke
parents:
diff changeset
  1510
        private boolean isDeprecatedOverrideIgnorable(MethodSymbol m, ClassSymbol origin) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1511
            // If the method, m, is defined in an interface, then ignore the issue if the method
06bc494ca11e Initial load
duke
parents:
diff changeset
  1512
            // is only inherited via a supertype and also implemented in the supertype,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1513
            // because in that case, we will rediscover the issue when examining the method
06bc494ca11e Initial load
duke
parents:
diff changeset
  1514
            // in the supertype.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1515
            // If the method, m, is not defined in an interface, then the only time we need to
06bc494ca11e Initial load
duke
parents:
diff changeset
  1516
            // address the issue is when the method is the supertype implemementation: any other
06bc494ca11e Initial load
duke
parents:
diff changeset
  1517
            // case, we will have dealt with when examining the supertype classes
06bc494ca11e Initial load
duke
parents:
diff changeset
  1518
            ClassSymbol mc = m.enclClass();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1519
            Type st = types.supertype(origin.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1520
            if (st.tag != CLASS)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1521
                return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1522
            MethodSymbol stimpl = m.implementation((ClassSymbol)st.tsym, types, false);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1523
06bc494ca11e Initial load
duke
parents:
diff changeset
  1524
            if (mc != null && ((mc.flags() & INTERFACE) != 0)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1525
                List<Type> intfs = types.interfaces(origin.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1526
                return (intfs.contains(mc.type) ? false : (stimpl != null));
06bc494ca11e Initial load
duke
parents:
diff changeset
  1527
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1528
            else
06bc494ca11e Initial load
duke
parents:
diff changeset
  1529
                return (stimpl != m);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1530
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1531
06bc494ca11e Initial load
duke
parents:
diff changeset
  1532
06bc494ca11e Initial load
duke
parents:
diff changeset
  1533
    // used to check if there were any unchecked conversions
06bc494ca11e Initial load
duke
parents:
diff changeset
  1534
    Warner overrideWarner = new Warner();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1535
06bc494ca11e Initial load
duke
parents:
diff changeset
  1536
    /** Check that a class does not inherit two concrete methods
06bc494ca11e Initial load
duke
parents:
diff changeset
  1537
     *  with the same signature.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1538
     *  @param pos          Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1539
     *  @param site         The class type to be checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1540
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1541
    public void checkCompatibleConcretes(DiagnosticPosition pos, Type site) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1542
        Type sup = types.supertype(site);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1543
        if (sup.tag != CLASS) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1544
06bc494ca11e Initial load
duke
parents:
diff changeset
  1545
        for (Type t1 = sup;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1546
             t1.tsym.type.isParameterized();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1547
             t1 = types.supertype(t1)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1548
            for (Scope.Entry e1 = t1.tsym.members().elems;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1549
                 e1 != null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1550
                 e1 = e1.sibling) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1551
                Symbol s1 = e1.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1552
                if (s1.kind != MTH ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1553
                    (s1.flags() & (STATIC|SYNTHETIC|BRIDGE)) != 0 ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1554
                    !s1.isInheritedIn(site.tsym, types) ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1555
                    ((MethodSymbol)s1).implementation(site.tsym,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1556
                                                      types,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1557
                                                      true) != s1)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1558
                    continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1559
                Type st1 = types.memberType(t1, s1);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1560
                int s1ArgsLength = st1.getParameterTypes().length();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1561
                if (st1 == s1.type) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1562
06bc494ca11e Initial load
duke
parents:
diff changeset
  1563
                for (Type t2 = sup;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1564
                     t2.tag == CLASS;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1565
                     t2 = types.supertype(t2)) {
508
118e500e2e50 5009937: hiding versus generics versus binary compatibility
mcimadamore
parents: 169
diff changeset
  1566
                    for (Scope.Entry e2 = t2.tsym.members().lookup(s1.name);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1567
                         e2.scope != null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1568
                         e2 = e2.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1569
                        Symbol s2 = e2.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1570
                        if (s2 == s1 ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1571
                            s2.kind != MTH ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1572
                            (s2.flags() & (STATIC|SYNTHETIC|BRIDGE)) != 0 ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1573
                            s2.type.getParameterTypes().length() != s1ArgsLength ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1574
                            !s2.isInheritedIn(site.tsym, types) ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1575
                            ((MethodSymbol)s2).implementation(site.tsym,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1576
                                                              types,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1577
                                                              true) != s2)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1578
                            continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1579
                        Type st2 = types.memberType(t2, s2);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1580
                        if (types.overrideEquivalent(st1, st2))
06bc494ca11e Initial load
duke
parents:
diff changeset
  1581
                            log.error(pos, "concrete.inheritance.conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1582
                                      s1, t1, s2, t2, sup);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1583
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1584
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1585
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1586
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1587
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1588
06bc494ca11e Initial load
duke
parents:
diff changeset
  1589
    /** Check that classes (or interfaces) do not each define an abstract
06bc494ca11e Initial load
duke
parents:
diff changeset
  1590
     *  method with same name and arguments but incompatible return types.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1591
     *  @param pos          Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1592
     *  @param t1           The first argument type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1593
     *  @param t2           The second argument type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1594
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1595
    public boolean checkCompatibleAbstracts(DiagnosticPosition pos,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1596
                                            Type t1,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1597
                                            Type t2) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1598
        return checkCompatibleAbstracts(pos, t1, t2,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1599
                                        types.makeCompoundType(t1, t2));
06bc494ca11e Initial load
duke
parents:
diff changeset
  1600
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1601
06bc494ca11e Initial load
duke
parents:
diff changeset
  1602
    public boolean checkCompatibleAbstracts(DiagnosticPosition pos,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1603
                                            Type t1,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1604
                                            Type t2,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1605
                                            Type site) {
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1606
        return firstIncompatibility(pos, t1, t2, site) == null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1607
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1608
06bc494ca11e Initial load
duke
parents:
diff changeset
  1609
    /** Return the first method which is defined with same args
06bc494ca11e Initial load
duke
parents:
diff changeset
  1610
     *  but different return types in two given interfaces, or null if none
06bc494ca11e Initial load
duke
parents:
diff changeset
  1611
     *  exists.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1612
     *  @param t1     The first type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1613
     *  @param t2     The second type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1614
     *  @param site   The most derived type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1615
     *  @returns symbol from t2 that conflicts with one in t1.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1616
     */
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1617
    private Symbol firstIncompatibility(DiagnosticPosition pos, Type t1, Type t2, Type site) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1618
        Map<TypeSymbol,Type> interfaces1 = new HashMap<TypeSymbol,Type>();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1619
        closure(t1, interfaces1);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1620
        Map<TypeSymbol,Type> interfaces2;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1621
        if (t1 == t2)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1622
            interfaces2 = interfaces1;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1623
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
  1624
            closure(t2, interfaces1, interfaces2 = new HashMap<TypeSymbol,Type>());
06bc494ca11e Initial load
duke
parents:
diff changeset
  1625
06bc494ca11e Initial load
duke
parents:
diff changeset
  1626
        for (Type t3 : interfaces1.values()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1627
            for (Type t4 : interfaces2.values()) {
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1628
                Symbol s = firstDirectIncompatibility(pos, t3, t4, site);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1629
                if (s != null) return s;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1630
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1631
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1632
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1633
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1634
06bc494ca11e Initial load
duke
parents:
diff changeset
  1635
    /** Compute all the supertypes of t, indexed by type symbol. */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1636
    private void closure(Type t, Map<TypeSymbol,Type> typeMap) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1637
        if (t.tag != CLASS) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1638
        if (typeMap.put(t.tsym, t) == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1639
            closure(types.supertype(t), typeMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1640
            for (Type i : types.interfaces(t))
06bc494ca11e Initial load
duke
parents:
diff changeset
  1641
                closure(i, typeMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1642
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1643
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1644
06bc494ca11e Initial load
duke
parents:
diff changeset
  1645
    /** Compute all the supertypes of t, indexed by type symbol (except thise in typesSkip). */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1646
    private void closure(Type t, Map<TypeSymbol,Type> typesSkip, Map<TypeSymbol,Type> typeMap) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1647
        if (t.tag != CLASS) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1648
        if (typesSkip.get(t.tsym) != null) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1649
        if (typeMap.put(t.tsym, t) == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1650
            closure(types.supertype(t), typesSkip, typeMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1651
            for (Type i : types.interfaces(t))
06bc494ca11e Initial load
duke
parents:
diff changeset
  1652
                closure(i, typesSkip, typeMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1653
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1654
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1655
06bc494ca11e Initial load
duke
parents:
diff changeset
  1656
    /** Return the first method in t2 that conflicts with a method from t1. */
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1657
    private Symbol firstDirectIncompatibility(DiagnosticPosition pos, Type t1, Type t2, Type site) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1658
        for (Scope.Entry e1 = t1.tsym.members().elems; e1 != null; e1 = e1.sibling) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1659
            Symbol s1 = e1.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1660
            Type st1 = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1661
            if (s1.kind != MTH || !s1.isInheritedIn(site.tsym, types)) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1662
            Symbol impl = ((MethodSymbol)s1).implementation(site.tsym, types, false);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1663
            if (impl != null && (impl.flags() & ABSTRACT) == 0) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1664
            for (Scope.Entry e2 = t2.tsym.members().lookup(s1.name); e2.scope != null; e2 = e2.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1665
                Symbol s2 = e2.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1666
                if (s1 == s2) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1667
                if (s2.kind != MTH || !s2.isInheritedIn(site.tsym, types)) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1668
                if (st1 == null) st1 = types.memberType(t1, s1);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1669
                Type st2 = types.memberType(t2, s2);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1670
                if (types.overrideEquivalent(st1, st2)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1671
                    List<Type> tvars1 = st1.getTypeArguments();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1672
                    List<Type> tvars2 = st2.getTypeArguments();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1673
                    Type rt1 = st1.getReturnType();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1674
                    Type rt2 = types.subst(st2.getReturnType(), tvars2, tvars1);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1675
                    boolean compat =
06bc494ca11e Initial load
duke
parents:
diff changeset
  1676
                        types.isSameType(rt1, rt2) ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  1677
                        rt1.tag >= CLASS && rt2.tag >= CLASS &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1678
                        (types.covariantReturnType(rt1, rt2, Warner.noWarnings) ||
812
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1679
                         types.covariantReturnType(rt2, rt1, Warner.noWarnings)) ||
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1680
                         checkCommonOverriderIn(s1,s2,site);
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1681
                    if (!compat) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1682
                        log.error(pos, "types.incompatible.diff.ret",
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1683
                            t1, t2, s2.name +
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1684
                            "(" + types.memberType(t2, s2).getParameterTypes() + ")");
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1685
                        return s2;
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1686
                    }
8610
62e3274feecc 7020657: Javac rejects a fairly common idiom with raw override and interfaces
mcimadamore
parents: 8427
diff changeset
  1687
                } else if (checkNameClash((ClassSymbol)site.tsym, s1, s2) &&
62e3274feecc 7020657: Javac rejects a fairly common idiom with raw override and interfaces
mcimadamore
parents: 8427
diff changeset
  1688
                        !checkCommonOverriderIn(s1, s2, site)) {
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1689
                    log.error(pos,
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1690
                            "name.clash.same.erasure.no.override",
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1691
                            s1, s1.location(),
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1692
                            s2, s2.location());
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1693
                    return s2;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1694
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1695
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1696
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1697
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1698
    }
812
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1699
    //WHERE
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1700
    boolean checkCommonOverriderIn(Symbol s1, Symbol s2, Type site) {
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1701
        Map<TypeSymbol,Type> supertypes = new HashMap<TypeSymbol,Type>();
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1702
        Type st1 = types.memberType(site, s1);
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1703
        Type st2 = types.memberType(site, s2);
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1704
        closure(site, supertypes);
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1705
        for (Type t : supertypes.values()) {
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1706
            for (Scope.Entry e = t.tsym.members().lookup(s1.name); e.scope != null; e = e.next()) {
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1707
                Symbol s3 = e.sym;
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1708
                if (s3 == s1 || s3 == s2 || s3.kind != MTH || (s3.flags() & (BRIDGE|SYNTHETIC)) != 0) continue;
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1709
                Type st3 = types.memberType(site,s3);
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1710
                if (types.overrideEquivalent(st3, st1) && types.overrideEquivalent(st3, st2)) {
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1711
                    if (s3.owner == site.tsym) {
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1712
                        return true;
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1713
                    }
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1714
                    List<Type> tvars1 = st1.getTypeArguments();
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1715
                    List<Type> tvars2 = st2.getTypeArguments();
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1716
                    List<Type> tvars3 = st3.getTypeArguments();
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1717
                    Type rt1 = st1.getReturnType();
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1718
                    Type rt2 = st2.getReturnType();
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1719
                    Type rt13 = types.subst(st3.getReturnType(), tvars3, tvars1);
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1720
                    Type rt23 = types.subst(st3.getReturnType(), tvars3, tvars2);
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1721
                    boolean compat =
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1722
                        rt13.tag >= CLASS && rt23.tag >= CLASS &&
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1723
                        (types.covariantReturnType(rt13, rt1, Warner.noWarnings) &&
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1724
                         types.covariantReturnType(rt23, rt2, Warner.noWarnings));
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1725
                    if (compat)
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1726
                        return true;
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1727
                }
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1728
            }
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1729
        }
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1730
        return false;
d60171f70ade 6294779: Problem with interface inheritance and covariant return types
mcimadamore
parents: 661
diff changeset
  1731
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1732
06bc494ca11e Initial load
duke
parents:
diff changeset
  1733
    /** Check that a given method conforms with any method it overrides.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1734
     *  @param tree         The tree from which positions are extracted
06bc494ca11e Initial load
duke
parents:
diff changeset
  1735
     *                      for errors.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1736
     *  @param m            The overriding method.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1737
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1738
    void checkOverride(JCTree tree, MethodSymbol m) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1739
        ClassSymbol origin = (ClassSymbol)m.owner;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1740
        if ((origin.flags() & ENUM) != 0 && names.finalize.equals(m.name))
06bc494ca11e Initial load
duke
parents:
diff changeset
  1741
            if (m.overrides(syms.enumFinalFinalize, origin, types, false)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1742
                log.error(tree.pos(), "enum.no.finalize");
06bc494ca11e Initial load
duke
parents:
diff changeset
  1743
                return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1744
            }
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1745
        for (Type t = origin.type; t.tag == CLASS;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1746
             t = types.supertype(t)) {
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1747
            if (t != origin.type) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1748
                checkOverride(tree, t, origin, m);
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1749
            }
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1750
            for (Type t2 : types.interfaces(t)) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1751
                checkOverride(tree, t2, origin, m);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1752
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1753
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1754
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1755
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1756
    void checkOverride(JCTree tree, Type site, ClassSymbol origin, MethodSymbol m) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1757
        TypeSymbol c = site.tsym;
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1758
        Scope.Entry e = c.members().lookup(m.name);
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1759
        while (e.scope != null) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1760
            if (m.overrides(e.sym, origin, types, false)) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1761
                if ((e.sym.flags() & ABSTRACT) == 0) {
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1762
                    checkOverride(tree, m, (MethodSymbol)e.sym, origin);
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1763
                }
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1764
            }
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1765
            e = e.next();
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1766
        }
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1767
    }
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1768
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1769
    private boolean checkNameClash(ClassSymbol origin, Symbol s1, Symbol s2) {
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  1770
        ClashFilter cf = new ClashFilter(origin.type);
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  1771
        return (cf.accepts(s1) &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  1772
                cf.accepts(s2) &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  1773
                types.hasSameArgs(s1.erasure(types), s2.erasure(types)));
7214
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1774
    }
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1775
26dfa4a69593 6985719: Alike methods in interfaces (Inheritance and Overriding)
mcimadamore
parents: 6721
diff changeset
  1776
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1777
    /** Check that all abstract members of given class have definitions.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1778
     *  @param pos          Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1779
     *  @param c            The class.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1780
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1781
    void checkAllDefined(DiagnosticPosition pos, ClassSymbol c) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1782
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1783
            MethodSymbol undef = firstUndef(c, c);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1784
            if (undef != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1785
                if ((c.flags() & ENUM) != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1786
                    types.supertype(c.type).tsym == syms.enumSym &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1787
                    (c.flags() & FINAL) == 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1788
                    // add the ABSTRACT flag to an enum
06bc494ca11e Initial load
duke
parents:
diff changeset
  1789
                    c.flags_field |= ABSTRACT;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1790
                } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1791
                    MethodSymbol undef1 =
06bc494ca11e Initial load
duke
parents:
diff changeset
  1792
                        new MethodSymbol(undef.flags(), undef.name,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1793
                                         types.memberType(c.type, undef), undef.owner);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1794
                    log.error(pos, "does.not.override.abstract",
06bc494ca11e Initial load
duke
parents:
diff changeset
  1795
                              c, undef1, undef1.location());
06bc494ca11e Initial load
duke
parents:
diff changeset
  1796
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1797
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1798
        } catch (CompletionFailure ex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1799
            completionError(pos, ex);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1800
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1801
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1802
//where
06bc494ca11e Initial load
duke
parents:
diff changeset
  1803
        /** Return first abstract member of class `c' that is not defined
06bc494ca11e Initial load
duke
parents:
diff changeset
  1804
         *  in `impl', null if there is none.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1805
         */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1806
        private MethodSymbol firstUndef(ClassSymbol impl, ClassSymbol c) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1807
            MethodSymbol undef = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1808
            // Do not bother to search in classes that are not abstract,
06bc494ca11e Initial load
duke
parents:
diff changeset
  1809
            // since they cannot have abstract members.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1810
            if (c == impl || (c.flags() & (ABSTRACT | INTERFACE)) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1811
                Scope s = c.members();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1812
                for (Scope.Entry e = s.elems;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1813
                     undef == null && e != null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1814
                     e = e.sibling) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1815
                    if (e.sym.kind == MTH &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  1816
                        (e.sym.flags() & (ABSTRACT|IPROXY)) == ABSTRACT) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1817
                        MethodSymbol absmeth = (MethodSymbol)e.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1818
                        MethodSymbol implmeth = absmeth.implementation(impl, types, true);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1819
                        if (implmeth == null || implmeth == absmeth)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1820
                            undef = absmeth;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1821
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1822
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1823
                if (undef == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1824
                    Type st = types.supertype(c.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1825
                    if (st.tag == CLASS)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1826
                        undef = firstUndef(impl, (ClassSymbol)st.tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1827
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1828
                for (List<Type> l = types.interfaces(c.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1829
                     undef == null && l.nonEmpty();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1830
                     l = l.tail) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1831
                    undef = firstUndef(impl, (ClassSymbol)l.head.tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1832
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1833
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1834
            return undef;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1835
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1836
6711
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1837
    void checkNonCyclicDecl(JCClassDecl tree) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1838
        CycleChecker cc = new CycleChecker();
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1839
        cc.scan(tree);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1840
        if (!cc.errorFound && !cc.partialCheck) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1841
            tree.sym.flags_field |= ACYCLIC;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1842
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1843
    }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1844
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1845
    class CycleChecker extends TreeScanner {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1846
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1847
        List<Symbol> seenClasses = List.nil();
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1848
        boolean errorFound = false;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1849
        boolean partialCheck = false;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1850
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1851
        private void checkSymbol(DiagnosticPosition pos, Symbol sym) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1852
            if (sym != null && sym.kind == TYP) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1853
                Env<AttrContext> classEnv = enter.getEnv((TypeSymbol)sym);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1854
                if (classEnv != null) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1855
                    DiagnosticSource prevSource = log.currentSource();
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1856
                    try {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1857
                        log.useSource(classEnv.toplevel.sourcefile);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1858
                        scan(classEnv.tree);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1859
                    }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1860
                    finally {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1861
                        log.useSource(prevSource.getFile());
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1862
                    }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1863
                } else if (sym.kind == TYP) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1864
                    checkClass(pos, sym, List.<JCTree>nil());
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1865
                }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1866
            } else {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1867
                //not completed yet
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1868
                partialCheck = true;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1869
            }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1870
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1871
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1872
        @Override
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1873
        public void visitSelect(JCFieldAccess tree) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1874
            super.visitSelect(tree);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1875
            checkSymbol(tree.pos(), tree.sym);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1876
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1877
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1878
        @Override
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1879
        public void visitIdent(JCIdent tree) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1880
            checkSymbol(tree.pos(), tree.sym);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1881
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1882
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1883
        @Override
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1884
        public void visitTypeApply(JCTypeApply tree) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1885
            scan(tree.clazz);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1886
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1887
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1888
        @Override
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1889
        public void visitTypeArray(JCArrayTypeTree tree) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1890
            scan(tree.elemtype);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1891
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1892
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1893
        @Override
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1894
        public void visitClassDef(JCClassDecl tree) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1895
            List<JCTree> supertypes = List.nil();
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1896
            if (tree.getExtendsClause() != null) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1897
                supertypes = supertypes.prepend(tree.getExtendsClause());
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1898
            }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1899
            if (tree.getImplementsClause() != null) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1900
                for (JCTree intf : tree.getImplementsClause()) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1901
                    supertypes = supertypes.prepend(intf);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1902
                }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1903
            }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1904
            checkClass(tree.pos(), tree.sym, supertypes);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1905
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1906
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1907
        void checkClass(DiagnosticPosition pos, Symbol c, List<JCTree> supertypes) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1908
            if ((c.flags_field & ACYCLIC) != 0)
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1909
                return;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1910
            if (seenClasses.contains(c)) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1911
                errorFound = true;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1912
                noteCyclic(pos, (ClassSymbol)c);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1913
            } else if (!c.type.isErroneous()) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1914
                try {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1915
                    seenClasses = seenClasses.prepend(c);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1916
                    if (c.type.tag == CLASS) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1917
                        if (supertypes.nonEmpty()) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1918
                            scan(supertypes);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1919
                        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1920
                        else {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1921
                            ClassType ct = (ClassType)c.type;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1922
                            if (ct.supertype_field == null ||
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1923
                                    ct.interfaces_field == null) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1924
                                //not completed yet
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1925
                                partialCheck = true;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1926
                                return;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1927
                            }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1928
                            checkSymbol(pos, ct.supertype_field.tsym);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1929
                            for (Type intf : ct.interfaces_field) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1930
                                checkSymbol(pos, intf.tsym);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1931
                            }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1932
                        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1933
                        if (c.owner.kind == TYP) {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1934
                            checkSymbol(pos, c.owner);
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1935
                        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1936
                    }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1937
                } finally {
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1938
                    seenClasses = seenClasses.tail;
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1939
                }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1940
            }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1941
        }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1942
    }
fc9732adc790 6863465: javac doesn't detect circular subclass dependencies via qualified names
mcimadamore
parents: 6352
diff changeset
  1943
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1944
    /** Check for cyclic references. Issue an error if the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1945
     *  symbol of the type referred to has a LOCKED flag set.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1946
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1947
     *  @param pos      Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1948
     *  @param t        The type referred to.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1949
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1950
    void checkNonCyclic(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1951
        checkNonCyclicInternal(pos, t);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1952
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1953
06bc494ca11e Initial load
duke
parents:
diff changeset
  1954
06bc494ca11e Initial load
duke
parents:
diff changeset
  1955
    void checkNonCyclic(DiagnosticPosition pos, TypeVar t) {
2219
03b1b17c4b2e 6804733: javac generates spourious diagnostics for ill-formed type-variable bounds
mcimadamore
parents: 1874
diff changeset
  1956
        checkNonCyclic1(pos, t, List.<TypeVar>nil());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1957
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1958
2219
03b1b17c4b2e 6804733: javac generates spourious diagnostics for ill-formed type-variable bounds
mcimadamore
parents: 1874
diff changeset
  1959
    private void checkNonCyclic1(DiagnosticPosition pos, Type t, List<TypeVar> seen) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1960
        final TypeVar tv;
661
9b2f1fe5c183 6677785: REGRESSION: StackOverFlowError with Cyclic Class level Type Parameters when used in constructors
mcimadamore
parents: 508
diff changeset
  1961
        if  (t.tag == TYPEVAR && (t.tsym.flags() & UNATTRIBUTED) != 0)
9b2f1fe5c183 6677785: REGRESSION: StackOverFlowError with Cyclic Class level Type Parameters when used in constructors
mcimadamore
parents: 508
diff changeset
  1962
            return;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1963
        if (seen.contains(t)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1964
            tv = (TypeVar)t;
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
  1965
            tv.bound = types.createErrorType(t);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1966
            log.error(pos, "cyclic.inheritance", t);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1967
        } else if (t.tag == TYPEVAR) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1968
            tv = (TypeVar)t;
2219
03b1b17c4b2e 6804733: javac generates spourious diagnostics for ill-formed type-variable bounds
mcimadamore
parents: 1874
diff changeset
  1969
            seen = seen.prepend(tv);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1970
            for (Type b : types.getBounds(tv))
06bc494ca11e Initial load
duke
parents:
diff changeset
  1971
                checkNonCyclic1(pos, b, seen);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1972
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1973
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1974
06bc494ca11e Initial load
duke
parents:
diff changeset
  1975
    /** Check for cyclic references. Issue an error if the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1976
     *  symbol of the type referred to has a LOCKED flag set.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1977
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1978
     *  @param pos      Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1979
     *  @param t        The type referred to.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1980
     *  @returns        True if the check completed on all attributed classes
06bc494ca11e Initial load
duke
parents:
diff changeset
  1981
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1982
    private boolean checkNonCyclicInternal(DiagnosticPosition pos, Type t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1983
        boolean complete = true; // was the check complete?
06bc494ca11e Initial load
duke
parents:
diff changeset
  1984
        //- System.err.println("checkNonCyclicInternal("+t+");");//DEBUG
06bc494ca11e Initial load
duke
parents:
diff changeset
  1985
        Symbol c = t.tsym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1986
        if ((c.flags_field & ACYCLIC) != 0) return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1987
06bc494ca11e Initial load
duke
parents:
diff changeset
  1988
        if ((c.flags_field & LOCKED) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1989
            noteCyclic(pos, (ClassSymbol)c);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1990
        } else if (!c.type.isErroneous()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1991
            try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1992
                c.flags_field |= LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1993
                if (c.type.tag == CLASS) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1994
                    ClassType clazz = (ClassType)c.type;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1995
                    if (clazz.interfaces_field != null)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1996
                        for (List<Type> l=clazz.interfaces_field; l.nonEmpty(); l=l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1997
                            complete &= checkNonCyclicInternal(pos, l.head);
06bc494ca11e Initial load
duke
parents:
diff changeset
  1998
                    if (clazz.supertype_field != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1999
                        Type st = clazz.supertype_field;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2000
                        if (st != null && st.tag == CLASS)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2001
                            complete &= checkNonCyclicInternal(pos, st);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2002
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2003
                    if (c.owner.kind == TYP)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2004
                        complete &= checkNonCyclicInternal(pos, c.owner.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2005
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2006
            } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2007
                c.flags_field &= ~LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2008
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2009
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2010
        if (complete)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2011
            complete = ((c.flags_field & UNATTRIBUTED) == 0) && c.completer == null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2012
        if (complete) c.flags_field |= ACYCLIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2013
        return complete;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2014
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2015
06bc494ca11e Initial load
duke
parents:
diff changeset
  2016
    /** Note that we found an inheritance cycle. */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2017
    private void noteCyclic(DiagnosticPosition pos, ClassSymbol c) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2018
        log.error(pos, "cyclic.inheritance", c);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2019
        for (List<Type> l=types.interfaces(c.type); l.nonEmpty(); l=l.tail)
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
  2020
            l.head = types.createErrorType((ClassSymbol)l.head.tsym, Type.noType);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2021
        Type st = types.supertype(c.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2022
        if (st.tag == CLASS)
1257
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
  2023
            ((ClassType)c.type).supertype_field = types.createErrorType((ClassSymbol)st.tsym, Type.noType);
873b053bf757 6557752: Original type of an AST should be made available even if it is replaced with an ErrorType
jjg
parents: 1040
diff changeset
  2024
        c.type = types.createErrorType(c, c.type);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2025
        c.flags_field |= ACYCLIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2026
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2027
06bc494ca11e Initial load
duke
parents:
diff changeset
  2028
    /** Check that all methods which implement some
06bc494ca11e Initial load
duke
parents:
diff changeset
  2029
     *  method conform to the method they implement.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2030
     *  @param tree         The class definition whose members are checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2031
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2032
    void checkImplementations(JCClassDecl tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2033
        checkImplementations(tree, tree.sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2034
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2035
//where
06bc494ca11e Initial load
duke
parents:
diff changeset
  2036
        /** Check that all methods which implement some
06bc494ca11e Initial load
duke
parents:
diff changeset
  2037
         *  method in `ic' conform to the method they implement.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2038
         */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2039
        void checkImplementations(JCClassDecl tree, ClassSymbol ic) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2040
            ClassSymbol origin = tree.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2041
            for (List<Type> l = types.closure(ic.type); l.nonEmpty(); l = l.tail) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2042
                ClassSymbol lc = (ClassSymbol)l.head.tsym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2043
                if ((allowGenerics || origin != lc) && (lc.flags() & ABSTRACT) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2044
                    for (Scope.Entry e=lc.members().elems; e != null; e=e.sibling) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2045
                        if (e.sym.kind == MTH &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2046
                            (e.sym.flags() & (STATIC|ABSTRACT)) == ABSTRACT) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2047
                            MethodSymbol absmeth = (MethodSymbol)e.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2048
                            MethodSymbol implmeth = absmeth.implementation(origin, types, false);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2049
                            if (implmeth != null && implmeth != absmeth &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2050
                                (implmeth.owner.flags() & INTERFACE) ==
06bc494ca11e Initial load
duke
parents:
diff changeset
  2051
                                (origin.flags() & INTERFACE)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2052
                                // don't check if implmeth is in a class, yet
06bc494ca11e Initial load
duke
parents:
diff changeset
  2053
                                // origin is an interface. This case arises only
06bc494ca11e Initial load
duke
parents:
diff changeset
  2054
                                // if implmeth is declared in Object. The reason is
06bc494ca11e Initial load
duke
parents:
diff changeset
  2055
                                // that interfaces really don't inherit from
06bc494ca11e Initial load
duke
parents:
diff changeset
  2056
                                // Object it's just that the compiler represents
06bc494ca11e Initial load
duke
parents:
diff changeset
  2057
                                // things that way.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2058
                                checkOverride(tree, implmeth, absmeth, origin);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2059
                            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2060
                        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2061
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2062
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2063
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2064
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2065
06bc494ca11e Initial load
duke
parents:
diff changeset
  2066
    /** Check that all abstract methods implemented by a class are
06bc494ca11e Initial load
duke
parents:
diff changeset
  2067
     *  mutually compatible.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2068
     *  @param pos          Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2069
     *  @param c            The class whose interfaces are checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2070
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2071
    void checkCompatibleSupertypes(DiagnosticPosition pos, Type c) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2072
        List<Type> supertypes = types.interfaces(c);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2073
        Type supertype = types.supertype(c);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2074
        if (supertype.tag == CLASS &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2075
            (supertype.tsym.flags() & ABSTRACT) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2076
            supertypes = supertypes.prepend(supertype);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2077
        for (List<Type> l = supertypes; l.nonEmpty(); l = l.tail) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2078
            if (allowGenerics && !l.head.getTypeArguments().isEmpty() &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2079
                !checkCompatibleAbstracts(pos, l.head, l.head, c))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2080
                return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2081
            for (List<Type> m = supertypes; m != l; m = m.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2082
                if (!checkCompatibleAbstracts(pos, l.head, m.head, c))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2083
                    return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2084
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2085
        checkCompatibleConcretes(pos, c);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2086
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2087
3557
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2088
    void checkConflicts(DiagnosticPosition pos, Symbol sym, TypeSymbol c) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2089
        for (Type ct = c.type; ct != Type.noType ; ct = types.supertype(ct)) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2090
            for (Scope.Entry e = ct.tsym.members().lookup(sym.name); e.scope == ct.tsym.members(); e = e.next()) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2091
                // VM allows methods and variables with differing types
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2092
                if (sym.kind == e.sym.kind &&
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2093
                    types.isSameType(types.erasure(sym.type), types.erasure(e.sym.type)) &&
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2094
                    sym != e.sym &&
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2095
                    (sym.flags() & Flags.SYNTHETIC) != (e.sym.flags() & Flags.SYNTHETIC) &&
6147
0074061d0efd 6964669: javac reports error on miranda methods
mcimadamore
parents: 6032
diff changeset
  2096
                    (sym.flags() & IPROXY) == 0 && (e.sym.flags() & IPROXY) == 0 &&
3557
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2097
                    (sym.flags() & BRIDGE) == 0 && (e.sym.flags() & BRIDGE) == 0) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2098
                    syntheticError(pos, (e.sym.flags() & SYNTHETIC) == 0 ? e.sym : sym);
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2099
                    return;
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2100
                }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2101
            }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2102
        }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2103
    }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2104
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2105
    /** Check that all non-override equivalent methods accessible from 'site'
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2106
     *  are mutually compatible (JLS 8.4.8/9.4.1).
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2107
     *
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2108
     *  @param pos  Position to be used for error reporting.
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2109
     *  @param site The class whose methods are checked.
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2110
     *  @param sym  The method symbol to be checked.
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2111
     */
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2112
    void checkOverrideClashes(DiagnosticPosition pos, Type site, MethodSymbol sym) {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2113
         ClashFilter cf = new ClashFilter(site);
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2114
         //for each method m1 that is a member of 'site'...
9812
f716e42cb230 7046348: Regression: javac complains of missing classfile for a seemingly unrelated interface
mcimadamore
parents: 9604
diff changeset
  2115
         for (Symbol s1 : types.membersClosure(site, false).getElementsByName(sym.name, cf)) {
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2116
            //...find another method m2 that is overridden (directly or indirectly)
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2117
            //by method 'sym' in 'site'
9812
f716e42cb230 7046348: Regression: javac complains of missing classfile for a seemingly unrelated interface
mcimadamore
parents: 9604
diff changeset
  2118
            for (Symbol s2 : types.membersClosure(site, false).getElementsByName(sym.name, cf)) {
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2119
                if (s1 == s2 || !sym.overrides(s2, site.tsym, types, false)) continue;
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2120
                //if (i) the signature of 'sym' is not a subsignature of m1 (seen as
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2121
                //a member of 'site') and (ii) m1 has the same erasure as m2, issue an error
8628
9e31f1c01bd4 7022054: Invalid compiler error on covariant overriding methods with the same erasure
mcimadamore
parents: 8610
diff changeset
  2122
                if (!types.isSubSignature(sym.type, types.memberType(site, s1), false) &&
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2123
                        types.hasSameArgs(s1.erasure(types), s2.erasure(types))) {
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2124
                    sym.flags_field |= CLASH;
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2125
                    String key = s2 == sym ?
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2126
                            "name.clash.same.erasure.no.override" :
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2127
                            "name.clash.same.erasure.no.override.1";
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2128
                    log.error(pos,
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2129
                            key,
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2130
                            sym, sym.location(),
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2131
                            s1, s1.location(),
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2132
                            s2, s2.location());
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2133
                    return;
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2134
                }
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2135
            }
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2136
        }
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2137
    }
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2138
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2139
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2140
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2141
    /** Check that all static methods accessible from 'site' are
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2142
     *  mutually compatible (JLS 8.4.8).
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2143
     *
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2144
     *  @param pos  Position to be used for error reporting.
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2145
     *  @param site The class whose methods are checked.
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2146
     *  @param sym  The method symbol to be checked.
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2147
     */
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2148
    void checkHideClashes(DiagnosticPosition pos, Type site, MethodSymbol sym) {
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2149
        ClashFilter cf = new ClashFilter(site);
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2150
        //for each method m1 that is a member of 'site'...
9812
f716e42cb230 7046348: Regression: javac complains of missing classfile for a seemingly unrelated interface
mcimadamore
parents: 9604
diff changeset
  2151
        for (Symbol s : types.membersClosure(site, true).getElementsByName(sym.name, cf)) {
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2152
            //if (i) the signature of 'sym' is not a subsignature of m1 (seen as
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2153
            //a member of 'site') and (ii) 'sym' has the same erasure as m1, issue an error
8628
9e31f1c01bd4 7022054: Invalid compiler error on covariant overriding methods with the same erasure
mcimadamore
parents: 8610
diff changeset
  2154
            if (!types.isSubSignature(sym.type, types.memberType(site, s), false) &&
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2155
                    types.hasSameArgs(s.erasure(types), sym.erasure(types))) {
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2156
                log.error(pos,
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2157
                        "name.clash.same.erasure.no.hide",
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2158
                        sym, sym.location(),
8427
703181b01773 7017664: Add listeners infrastracture to javac scopes
mcimadamore
parents: 8242
diff changeset
  2159
                        s, s.location());
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2160
                return;
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2161
             }
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2162
         }
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2163
     }
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2164
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2165
     //where
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2166
     private class ClashFilter implements Filter<Symbol> {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2167
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2168
         Type site;
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2169
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2170
         ClashFilter(Type site) {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2171
             this.site = site;
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2172
         }
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2173
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2174
         boolean shouldSkip(Symbol s) {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2175
             return (s.flags() & CLASH) != 0 &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2176
                s.owner == site.tsym;
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2177
         }
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2178
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2179
         public boolean accepts(Symbol s) {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2180
             return s.kind == MTH &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2181
                     (s.flags() & SYNTHETIC) == 0 &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2182
                     !shouldSkip(s) &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2183
                     s.isInheritedIn(site.tsym, types) &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2184
                     !s.isConstructor();
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2185
         }
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2186
     }
7628
e7baeb97d164 6476118: compiler bug causes runtime ClassCastException for generics overloading
mcimadamore
parents: 7214
diff changeset
  2187
3557
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2188
    /** Report a conflict between a user symbol and a synthetic symbol.
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2189
     */
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2190
    private void syntheticError(DiagnosticPosition pos, Symbol sym) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2191
        if (!sym.type.isErroneous()) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2192
            if (warnOnSyntheticConflicts) {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2193
                log.warning(pos, "synthetic.name.conflict", sym, sym.location());
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2194
            }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2195
            else {
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2196
                log.error(pos, "synthetic.name.conflict", sym, sym.location());
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2197
            }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2198
        }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2199
    }
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3149
diff changeset
  2200
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2201
    /** Check that class c does not implement directly or indirectly
06bc494ca11e Initial load
duke
parents:
diff changeset
  2202
     *  the same parameterized interface with two different argument lists.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2203
     *  @param pos          Position to be used for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2204
     *  @param type         The type whose interfaces are checked.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2205
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2206
    void checkClassBounds(DiagnosticPosition pos, Type type) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2207
        checkClassBounds(pos, new HashMap<TypeSymbol,Type>(), type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2208
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2209
//where
06bc494ca11e Initial load
duke
parents:
diff changeset
  2210
        /** Enter all interfaces of type `type' into the hash table `seensofar'
06bc494ca11e Initial load
duke
parents:
diff changeset
  2211
         *  with their class symbol as key and their type as value. Make
06bc494ca11e Initial load
duke
parents:
diff changeset
  2212
         *  sure no class is entered with two different types.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2213
         */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2214
        void checkClassBounds(DiagnosticPosition pos,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2215
                              Map<TypeSymbol,Type> seensofar,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2216
                              Type type) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2217
            if (type.isErroneous()) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2218
            for (List<Type> l = types.interfaces(type); l.nonEmpty(); l = l.tail) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2219
                Type it = l.head;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2220
                Type oldit = seensofar.put(it.tsym, it);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2221
                if (oldit != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2222
                    List<Type> oldparams = oldit.allparams();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2223
                    List<Type> newparams = it.allparams();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2224
                    if (!types.containsTypeEquivalent(oldparams, newparams))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2225
                        log.error(pos, "cant.inherit.diff.arg",
06bc494ca11e Initial load
duke
parents:
diff changeset
  2226
                                  it.tsym, Type.toString(oldparams),
06bc494ca11e Initial load
duke
parents:
diff changeset
  2227
                                  Type.toString(newparams));
06bc494ca11e Initial load
duke
parents:
diff changeset
  2228
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2229
                checkClassBounds(pos, seensofar, it);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2230
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2231
            Type st = types.supertype(type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2232
            if (st != null) checkClassBounds(pos, seensofar, st);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2233
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2234
06bc494ca11e Initial load
duke
parents:
diff changeset
  2235
    /** Enter interface into into set.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2236
     *  If it existed already, issue a "repeated interface" error.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2237
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2238
    void checkNotRepeated(DiagnosticPosition pos, Type it, Set<Type> its) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2239
        if (its.contains(it))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2240
            log.error(pos, "repeated.interface");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2241
        else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2242
            its.add(it);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2243
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2244
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2245
06bc494ca11e Initial load
duke
parents:
diff changeset
  2246
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  2247
 * Check annotations
06bc494ca11e Initial load
duke
parents:
diff changeset
  2248
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  2249
6342
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2250
    /**
6347
947437d52cc1 6976649: javac does not enforce required annotation elements in arrays
mcimadamore
parents: 6345
diff changeset
  2251
     * Recursively validate annotations values
6342
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2252
     */
6347
947437d52cc1 6976649: javac does not enforce required annotation elements in arrays
mcimadamore
parents: 6345
diff changeset
  2253
    void validateAnnotationTree(JCTree tree) {
947437d52cc1 6976649: javac does not enforce required annotation elements in arrays
mcimadamore
parents: 6345
diff changeset
  2254
        class AnnotationValidator extends TreeScanner {
6342
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2255
            @Override
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2256
            public void visitAnnotation(JCAnnotation tree) {
9814
978b696e85ad 7042623: Regression: javac silently crash when attributing non-existent annotation
jjg
parents: 9812
diff changeset
  2257
                if (!tree.type.isErroneous()) {
978b696e85ad 7042623: Regression: javac silently crash when attributing non-existent annotation
jjg
parents: 9812
diff changeset
  2258
                    super.visitAnnotation(tree);
978b696e85ad 7042623: Regression: javac silently crash when attributing non-existent annotation
jjg
parents: 9812
diff changeset
  2259
                    validateAnnotation(tree);
978b696e85ad 7042623: Regression: javac silently crash when attributing non-existent annotation
jjg
parents: 9812
diff changeset
  2260
                }
6342
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2261
            }
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2262
        }
6347
947437d52cc1 6976649: javac does not enforce required annotation elements in arrays
mcimadamore
parents: 6345
diff changeset
  2263
        tree.accept(new AnnotationValidator());
6342
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2264
    }
228b73431edb 6881115: javac permits nested anno w/o mandatory attrs => IncompleteAnnotationException
mcimadamore
parents: 6151
diff changeset
  2265
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2266
    /** Annotation types are restricted to primitives, String, an
06bc494ca11e Initial load
duke
parents:
diff changeset
  2267
     *  enum, an annotation, Class, Class<?>, Class<? extends
06bc494ca11e Initial load
duke
parents:
diff changeset
  2268
     *  Anything>, arrays of the preceding.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2269
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2270
    void validateAnnotationType(JCTree restype) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2271
        // restype may be null if an error occurred, so don't bother validating it
06bc494ca11e Initial load
duke
parents:
diff changeset
  2272
        if (restype != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2273
            validateAnnotationType(restype.pos(), restype.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2274
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2275
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2276
06bc494ca11e Initial load
duke
parents:
diff changeset
  2277
    void validateAnnotationType(DiagnosticPosition pos, Type type) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2278
        if (type.isPrimitive()) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2279
        if (types.isSameType(type, syms.stringType)) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2280
        if ((type.tsym.flags() & Flags.ENUM) != 0) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2281
        if ((type.tsym.flags() & Flags.ANNOTATION) != 0) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2282
        if (types.lowerBound(type).tsym == syms.classType.tsym) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2283
        if (types.isArray(type) && !types.isArray(types.elemtype(type))) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2284
            validateAnnotationType(pos, types.elemtype(type));
06bc494ca11e Initial load
duke
parents:
diff changeset
  2285
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2286
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2287
        log.error(pos, "invalid.annotation.member.type");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2288
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2289
06bc494ca11e Initial load
duke
parents:
diff changeset
  2290
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  2291
     * "It is also a compile-time error if any method declared in an
06bc494ca11e Initial load
duke
parents:
diff changeset
  2292
     * annotation type has a signature that is override-equivalent to
06bc494ca11e Initial load
duke
parents:
diff changeset
  2293
     * that of any public or protected method declared in class Object
06bc494ca11e Initial load
duke
parents:
diff changeset
  2294
     * or in the interface annotation.Annotation."
06bc494ca11e Initial load
duke
parents:
diff changeset
  2295
     *
9303
eae35c201e19 7032975: API files in javax.annotation.processing need to be updated for references to JLS
jjh
parents: 9073
diff changeset
  2296
     * @jls 9.6 Annotation Types
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2297
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2298
    void validateAnnotationMethod(DiagnosticPosition pos, MethodSymbol m) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2299
        for (Type sup = syms.annotationType; sup.tag == CLASS; sup = types.supertype(sup)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2300
            Scope s = sup.tsym.members();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2301
            for (Scope.Entry e = s.lookup(m.name); e.scope != null; e = e.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2302
                if (e.sym.kind == MTH &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2303
                    (e.sym.flags() & (PUBLIC | PROTECTED)) != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2304
                    types.overrideEquivalent(m.type, e.sym.type))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2305
                    log.error(pos, "intf.annotation.member.clash", e.sym, sup);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2306
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2307
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2308
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2309
06bc494ca11e Initial load
duke
parents:
diff changeset
  2310
    /** Check the annotations of a symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2311
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2312
    public void validateAnnotations(List<JCAnnotation> annotations, Symbol s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2313
        if (skipAnnotations) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2314
        for (JCAnnotation a : annotations)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2315
            validateAnnotation(a, s);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2316
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2317
06bc494ca11e Initial load
duke
parents:
diff changeset
  2318
    /** Check an annotation of a symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2319
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2320
    public void validateAnnotation(JCAnnotation a, Symbol s) {
6347
947437d52cc1 6976649: javac does not enforce required annotation elements in arrays
mcimadamore
parents: 6345
diff changeset
  2321
        validateAnnotationTree(a);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2322
06bc494ca11e Initial load
duke
parents:
diff changeset
  2323
        if (!annotationApplicable(a, s))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2324
            log.error(a.pos(), "annotation.type.not.applicable");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2325
06bc494ca11e Initial load
duke
parents:
diff changeset
  2326
        if (a.annotationType.type.tsym == syms.overrideType.tsym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2327
            if (!isOverrider(s))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2328
                log.error(a.pos(), "method.does.not.override.superclass");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2329
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2330
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2331
06bc494ca11e Initial load
duke
parents:
diff changeset
  2332
    /** Is s a method symbol that overrides a method in a superclass? */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2333
    boolean isOverrider(Symbol s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2334
        if (s.kind != MTH || s.isStatic())
06bc494ca11e Initial load
duke
parents:
diff changeset
  2335
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2336
        MethodSymbol m = (MethodSymbol)s;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2337
        TypeSymbol owner = (TypeSymbol)m.owner;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2338
        for (Type sup : types.closure(owner.type)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2339
            if (sup == owner.type)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2340
                continue; // skip "this"
06bc494ca11e Initial load
duke
parents:
diff changeset
  2341
            Scope scope = sup.tsym.members();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2342
            for (Scope.Entry e = scope.lookup(m.name); e.scope != null; e = e.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2343
                if (!e.sym.isStatic() && m.overrides(e.sym, owner, types, true))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2344
                    return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2345
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2346
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2347
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2348
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2349
06bc494ca11e Initial load
duke
parents:
diff changeset
  2350
    /** Is the annotation applicable to the symbol? */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2351
    boolean annotationApplicable(JCAnnotation a, Symbol s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2352
        Attribute.Compound atTarget =
06bc494ca11e Initial load
duke
parents:
diff changeset
  2353
            a.annotationType.type.tsym.attribute(syms.annotationTargetType.tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2354
        if (atTarget == null) return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2355
        Attribute atValue = atTarget.member(names.value);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2356
        if (!(atValue instanceof Attribute.Array)) return true; // error recovery
06bc494ca11e Initial load
duke
parents:
diff changeset
  2357
        Attribute.Array arr = (Attribute.Array) atValue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2358
        for (Attribute app : arr.values) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2359
            if (!(app instanceof Attribute.Enum)) return true; // recovery
06bc494ca11e Initial load
duke
parents:
diff changeset
  2360
            Attribute.Enum e = (Attribute.Enum) app;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2361
            if (e.value.name == names.TYPE)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2362
                { if (s.kind == TYP) return true; }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2363
            else if (e.value.name == names.FIELD)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2364
                { if (s.kind == VAR && s.owner.kind != MTH) return true; }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2365
            else if (e.value.name == names.METHOD)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2366
                { if (s.kind == MTH && !s.isConstructor()) return true; }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2367
            else if (e.value.name == names.PARAMETER)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2368
                { if (s.kind == VAR &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2369
                      s.owner.kind == MTH &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2370
                      (s.flags() & PARAMETER) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2371
                    return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2372
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2373
            else if (e.value.name == names.CONSTRUCTOR)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2374
                { if (s.kind == MTH && s.isConstructor()) return true; }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2375
            else if (e.value.name == names.LOCAL_VARIABLE)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2376
                { if (s.kind == VAR && s.owner.kind == MTH &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2377
                      (s.flags() & PARAMETER) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2378
                    return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2379
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2380
            else if (e.value.name == names.ANNOTATION_TYPE)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2381
                { if (s.kind == TYP && (s.flags() & ANNOTATION) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2382
                    return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2383
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2384
            else if (e.value.name == names.PACKAGE)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2385
                { if (s.kind == PCK) return true; }
3149
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2386
            else if (e.value.name == names.TYPE_USE)
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2387
                { if (s.kind == TYP ||
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2388
                      s.kind == VAR ||
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2389
                      (s.kind == MTH && !s.isConstructor() &&
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2390
                       s.type.getReturnType().tag != VOID))
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2391
                    return true;
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  2392
                }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2393
            else
06bc494ca11e Initial load
duke
parents:
diff changeset
  2394
                return true; // recovery
06bc494ca11e Initial load
duke
parents:
diff changeset
  2395
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2396
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2397
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2398
06bc494ca11e Initial load
duke
parents:
diff changeset
  2399
    /** Check an annotation value.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2400
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2401
    public void validateAnnotation(JCAnnotation a) {
6345
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2402
        // collect an inventory of the members (sorted alphabetically)
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2403
        Set<MethodSymbol> members = new TreeSet<MethodSymbol>(new Comparator<Symbol>() {
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2404
            public int compare(Symbol t, Symbol t1) {
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2405
                return t.name.compareTo(t1.name);
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2406
            }
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2407
        });
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2408
        for (Scope.Entry e = a.annotationType.type.tsym.members().elems;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2409
             e != null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2410
             e = e.sibling)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2411
            if (e.sym.kind == MTH)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2412
                members.add((MethodSymbol) e.sym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2413
06bc494ca11e Initial load
duke
parents:
diff changeset
  2414
        // count them off as they're annotated
06bc494ca11e Initial load
duke
parents:
diff changeset
  2415
        for (JCTree arg : a.args) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2416
            if (arg.getTag() != JCTree.ASSIGN) continue; // recovery
06bc494ca11e Initial load
duke
parents:
diff changeset
  2417
            JCAssign assign = (JCAssign) arg;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2418
            Symbol m = TreeInfo.symbol(assign.lhs);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2419
            if (m == null || m.type.isErroneous()) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2420
            if (!members.remove(m))
4867
7f4efc9b2f9f 6919944: incorrect position given for duplicate annotation value error
jjg
parents: 3780
diff changeset
  2421
                log.error(assign.lhs.pos(), "duplicate.annotation.member.value",
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2422
                          m.name, a.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2423
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2424
06bc494ca11e Initial load
duke
parents:
diff changeset
  2425
        // all the remaining ones better have default values
6345
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2426
        ListBuffer<Name> missingDefaults = ListBuffer.lb();
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2427
        for (MethodSymbol m : members) {
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2428
            if (m.defaultValue == null && !m.type.isErroneous()) {
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2429
                missingDefaults.append(m.name);
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2430
            }
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2431
        }
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2432
        if (missingDefaults.nonEmpty()) {
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2433
            String key = (missingDefaults.size() > 1)
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2434
                    ? "annotation.missing.default.value.1"
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2435
                    : "annotation.missing.default.value";
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2436
            log.error(a.pos(), key, a.type, missingDefaults);
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6342
diff changeset
  2437
        }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2438
06bc494ca11e Initial load
duke
parents:
diff changeset
  2439
        // special case: java.lang.annotation.Target must not have
06bc494ca11e Initial load
duke
parents:
diff changeset
  2440
        // repeated values in its value member
06bc494ca11e Initial load
duke
parents:
diff changeset
  2441
        if (a.annotationType.type.tsym != syms.annotationTargetType.tsym ||
06bc494ca11e Initial load
duke
parents:
diff changeset
  2442
            a.args.tail == null)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2443
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2444
06bc494ca11e Initial load
duke
parents:
diff changeset
  2445
        if (a.args.head.getTag() != JCTree.ASSIGN) return; // error recovery
06bc494ca11e Initial load
duke
parents:
diff changeset
  2446
        JCAssign assign = (JCAssign) a.args.head;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2447
        Symbol m = TreeInfo.symbol(assign.lhs);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2448
        if (m.name != names.value) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2449
        JCTree rhs = assign.rhs;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2450
        if (rhs.getTag() != JCTree.NEWARRAY) return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2451
        JCNewArray na = (JCNewArray) rhs;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2452
        Set<Symbol> targets = new HashSet<Symbol>();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2453
        for (JCTree elem : na.elems) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2454
            if (!targets.add(TreeInfo.symbol(elem))) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2455
                log.error(elem.pos(), "repeated.annotation.target");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2456
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2457
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2458
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2459
06bc494ca11e Initial load
duke
parents:
diff changeset
  2460
    void checkDeprecatedAnnotation(DiagnosticPosition pos, Symbol s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2461
        if (allowAnnotations &&
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2462
            lint.isEnabled(LintCategory.DEP_ANN) &&
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2463
            (s.flags() & DEPRECATED) != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2464
            !syms.deprecatedType.isErroneous() &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2465
            s.attribute(syms.deprecatedType.tsym) == null) {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2466
            log.warning(LintCategory.DEP_ANN,
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  2467
                    pos, "missing.deprecated.annotation");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2468
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2469
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2470
8236
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2471
    void checkDeprecated(final DiagnosticPosition pos, final Symbol other, final Symbol s) {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2472
        if ((s.flags() & DEPRECATED) != 0 &&
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2473
                (other.flags() & DEPRECATED) == 0 &&
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2474
                s.outermostClass() != other.outermostClass()) {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2475
            deferredLintHandler.report(new DeferredLintHandler.LintLogger() {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2476
                @Override
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2477
                public void report() {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2478
                    warnDeprecated(pos, s);
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2479
                }
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2480
            });
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2481
        };
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2482
    }
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2483
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2484
    void checkSunAPI(final DiagnosticPosition pos, final Symbol s) {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2485
        if ((s.flags() & PROPRIETARY) != 0) {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2486
            deferredLintHandler.report(new DeferredLintHandler.LintLogger() {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2487
                public void report() {
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2488
                    if (enableSunApiLintControl)
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2489
                      warnSunApi(pos, "sun.proprietary", s);
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2490
                    else
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2491
                      log.strictWarning(pos, "sun.proprietary", s);
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2492
                }
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2493
            });
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2494
        }
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2495
    }
0d8646b7c602 6594914: @SuppressWarnings("deprecation") does not not work for the type of a variable
mcimadamore
parents: 8229
diff changeset
  2496
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2497
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  2498
 * Check for recursive annotation elements.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2499
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  2500
06bc494ca11e Initial load
duke
parents:
diff changeset
  2501
    /** Check for cycles in the graph of annotation elements.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2502
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2503
    void checkNonCyclicElements(JCClassDecl tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2504
        if ((tree.sym.flags_field & ANNOTATION) == 0) return;
8032
e1aa25ccdabb 6396503: javac should not require assertions enabled
jjg
parents: 8031
diff changeset
  2505
        Assert.check((tree.sym.flags_field & LOCKED) == 0);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2506
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2507
            tree.sym.flags_field |= LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2508
            for (JCTree def : tree.defs) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2509
                if (def.getTag() != JCTree.METHODDEF) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2510
                JCMethodDecl meth = (JCMethodDecl)def;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2511
                checkAnnotationResType(meth.pos(), meth.restype.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2512
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2513
        } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2514
            tree.sym.flags_field &= ~LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2515
            tree.sym.flags_field |= ACYCLIC_ANN;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2516
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2517
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2518
06bc494ca11e Initial load
duke
parents:
diff changeset
  2519
    void checkNonCyclicElementsInternal(DiagnosticPosition pos, TypeSymbol tsym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2520
        if ((tsym.flags_field & ACYCLIC_ANN) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2521
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2522
        if ((tsym.flags_field & LOCKED) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2523
            log.error(pos, "cyclic.annotation.element");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2524
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2525
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2526
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2527
            tsym.flags_field |= LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2528
            for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2529
                Symbol s = e.sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2530
                if (s.kind != Kinds.MTH)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2531
                    continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2532
                checkAnnotationResType(pos, ((MethodSymbol)s).type.getReturnType());
06bc494ca11e Initial load
duke
parents:
diff changeset
  2533
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2534
        } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2535
            tsym.flags_field &= ~LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2536
            tsym.flags_field |= ACYCLIC_ANN;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2537
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2538
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2539
06bc494ca11e Initial load
duke
parents:
diff changeset
  2540
    void checkAnnotationResType(DiagnosticPosition pos, Type type) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2541
        switch (type.tag) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2542
        case TypeTags.CLASS:
06bc494ca11e Initial load
duke
parents:
diff changeset
  2543
            if ((type.tsym.flags() & ANNOTATION) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2544
                checkNonCyclicElementsInternal(pos, type.tsym);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2545
            break;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2546
        case TypeTags.ARRAY:
06bc494ca11e Initial load
duke
parents:
diff changeset
  2547
            checkAnnotationResType(pos, types.elemtype(type));
06bc494ca11e Initial load
duke
parents:
diff changeset
  2548
            break;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2549
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
  2550
            break; // int etc
06bc494ca11e Initial load
duke
parents:
diff changeset
  2551
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2552
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2553
06bc494ca11e Initial load
duke
parents:
diff changeset
  2554
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  2555
 * Check for cycles in the constructor call graph.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2556
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  2557
06bc494ca11e Initial load
duke
parents:
diff changeset
  2558
    /** Check for cycles in the graph of constructors calling other
06bc494ca11e Initial load
duke
parents:
diff changeset
  2559
     *  constructors.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2560
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2561
    void checkCyclicConstructors(JCClassDecl tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2562
        Map<Symbol,Symbol> callMap = new HashMap<Symbol, Symbol>();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2563
06bc494ca11e Initial load
duke
parents:
diff changeset
  2564
        // enter each constructor this-call into the map
06bc494ca11e Initial load
duke
parents:
diff changeset
  2565
        for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2566
            JCMethodInvocation app = TreeInfo.firstConstructorCall(l.head);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2567
            if (app == null) continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2568
            JCMethodDecl meth = (JCMethodDecl) l.head;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2569
            if (TreeInfo.name(app.meth) == names._this) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2570
                callMap.put(meth.sym, TreeInfo.symbol(app.meth));
06bc494ca11e Initial load
duke
parents:
diff changeset
  2571
            } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2572
                meth.sym.flags_field |= ACYCLIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2573
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2574
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2575
06bc494ca11e Initial load
duke
parents:
diff changeset
  2576
        // Check for cycles in the map
06bc494ca11e Initial load
duke
parents:
diff changeset
  2577
        Symbol[] ctors = new Symbol[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
  2578
        ctors = callMap.keySet().toArray(ctors);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2579
        for (Symbol caller : ctors) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2580
            checkCyclicConstructor(tree, caller, callMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2581
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2582
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2583
06bc494ca11e Initial load
duke
parents:
diff changeset
  2584
    /** Look in the map to see if the given constructor is part of a
06bc494ca11e Initial load
duke
parents:
diff changeset
  2585
     *  call cycle.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2586
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2587
    private void checkCyclicConstructor(JCClassDecl tree, Symbol ctor,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2588
                                        Map<Symbol,Symbol> callMap) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2589
        if (ctor != null && (ctor.flags_field & ACYCLIC) == 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2590
            if ((ctor.flags_field & LOCKED) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2591
                log.error(TreeInfo.diagnosticPositionFor(ctor, tree),
06bc494ca11e Initial load
duke
parents:
diff changeset
  2592
                          "recursive.ctor.invocation");
06bc494ca11e Initial load
duke
parents:
diff changeset
  2593
            } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2594
                ctor.flags_field |= LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2595
                checkCyclicConstructor(tree, callMap.remove(ctor), callMap);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2596
                ctor.flags_field &= ~LOCKED;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2597
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2598
            ctor.flags_field |= ACYCLIC;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2599
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2600
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2601
06bc494ca11e Initial load
duke
parents:
diff changeset
  2602
/* *************************************************************************
06bc494ca11e Initial load
duke
parents:
diff changeset
  2603
 * Miscellaneous
06bc494ca11e Initial load
duke
parents:
diff changeset
  2604
 **************************************************************************/
06bc494ca11e Initial load
duke
parents:
diff changeset
  2605
06bc494ca11e Initial load
duke
parents:
diff changeset
  2606
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  2607
     * Return the opcode of the operator but emit an error if it is an
06bc494ca11e Initial load
duke
parents:
diff changeset
  2608
     * error.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2609
     * @param pos        position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2610
     * @param operator   an operator
06bc494ca11e Initial load
duke
parents:
diff changeset
  2611
     * @param tag        a tree tag
06bc494ca11e Initial load
duke
parents:
diff changeset
  2612
     * @param left       type of left hand side
06bc494ca11e Initial load
duke
parents:
diff changeset
  2613
     * @param right      type of right hand side
06bc494ca11e Initial load
duke
parents:
diff changeset
  2614
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2615
    int checkOperator(DiagnosticPosition pos,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2616
                       OperatorSymbol operator,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2617
                       int tag,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2618
                       Type left,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2619
                       Type right) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2620
        if (operator.opcode == ByteCodes.error) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2621
            log.error(pos,
8237
d5ef8db7ad09 5017953: spurious cascaded diagnostics when name not found
mcimadamore
parents: 8236
diff changeset
  2622
                      "operator.cant.be.applied.1",
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2623
                      treeinfo.operatorName(tag),
8237
d5ef8db7ad09 5017953: spurious cascaded diagnostics when name not found
mcimadamore
parents: 8236
diff changeset
  2624
                      left, right);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2625
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2626
        return operator.opcode;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2627
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2628
06bc494ca11e Initial load
duke
parents:
diff changeset
  2629
06bc494ca11e Initial load
duke
parents:
diff changeset
  2630
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  2631
     *  Check for division by integer constant zero
06bc494ca11e Initial load
duke
parents:
diff changeset
  2632
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2633
     *  @param operator      The operator for the expression
06bc494ca11e Initial load
duke
parents:
diff changeset
  2634
     *  @param operand       The right hand operand for the expression
06bc494ca11e Initial load
duke
parents:
diff changeset
  2635
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2636
    void checkDivZero(DiagnosticPosition pos, Symbol operator, Type operand) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2637
        if (operand.constValue() != null
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2638
            && lint.isEnabled(LintCategory.DIVZERO)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2639
            && operand.tag <= LONG
06bc494ca11e Initial load
duke
parents:
diff changeset
  2640
            && ((Number) (operand.constValue())).longValue() == 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2641
            int opc = ((OperatorSymbol)operator).opcode;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2642
            if (opc == ByteCodes.idiv || opc == ByteCodes.imod
06bc494ca11e Initial load
duke
parents:
diff changeset
  2643
                || opc == ByteCodes.ldiv || opc == ByteCodes.lmod) {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2644
                log.warning(LintCategory.DIVZERO, pos, "div.zero");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2645
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2646
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2647
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2648
06bc494ca11e Initial load
duke
parents:
diff changeset
  2649
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  2650
     * Check for empty statements after if
06bc494ca11e Initial load
duke
parents:
diff changeset
  2651
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2652
    void checkEmptyIf(JCIf tree) {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2653
        if (tree.thenpart.getTag() == JCTree.SKIP && tree.elsepart == null && lint.isEnabled(LintCategory.EMPTY))
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2654
            log.warning(LintCategory.EMPTY, tree.thenpart.pos(), "empty.if");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2655
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2656
06bc494ca11e Initial load
duke
parents:
diff changeset
  2657
    /** Check that symbol is unique in given scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2658
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2659
     *  @param sym           The symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2660
     *  @param s             The scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2661
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2662
    boolean checkUnique(DiagnosticPosition pos, Symbol sym, Scope s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2663
        if (sym.type.isErroneous())
06bc494ca11e Initial load
duke
parents:
diff changeset
  2664
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2665
        if (sym.owner.name == names.any) return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2666
        for (Scope.Entry e = s.lookup(sym.name); e.scope == s; e = e.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2667
            if (sym != e.sym &&
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2668
                    (e.sym.flags() & CLASH) == 0 &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2669
                    sym.kind == e.sym.kind &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2670
                    sym.name != names.error &&
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2671
                    (sym.kind != MTH || types.hasSameArgs(types.erasure(sym.type), types.erasure(e.sym.type)))) {
8228
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2672
                if ((sym.flags() & VARARGS) != (e.sym.flags() & VARARGS)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2673
                    varargsDuplicateError(pos, sym, e.sym);
8228
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2674
                    return true;
8628
9e31f1c01bd4 7022054: Invalid compiler error on covariant overriding methods with the same erasure
mcimadamore
parents: 8610
diff changeset
  2675
                } else if (sym.kind == MTH && !types.hasSameArgs(sym.type, e.sym.type, false)) {
2509
c8a1744c87fd 6182950: methods clash algorithm should not depend on return type
mcimadamore
parents: 2223
diff changeset
  2676
                    duplicateErasureError(pos, sym, e.sym);
8228
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2677
                    sym.flags_field |= CLASH;
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2678
                    return true;
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2679
                } else {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2680
                    duplicateError(pos, e.sym);
8228
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2681
                    return false;
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2682
                }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2683
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2684
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2685
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2686
    }
8228
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2687
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2688
    /** Report duplicate declaration error.
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2689
     */
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2690
    void duplicateErasureError(DiagnosticPosition pos, Symbol sym1, Symbol sym2) {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2691
        if (!sym1.type.isErroneous() && !sym2.type.isErroneous()) {
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2692
            log.error(pos, "name.clash.same.erasure", sym1, sym2);
8228
4e6ee38974b2 6910550: javac 1.5.0_17 fails with incorrect error message
mcimadamore
parents: 8045
diff changeset
  2693
        }
8242
3873b4aaf4a8 7007615: java_util/generics/phase2/NameClashTest02 fails since jdk7/pit/b123.
mcimadamore
parents: 8238
diff changeset
  2694
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2695
06bc494ca11e Initial load
duke
parents:
diff changeset
  2696
    /** Check that single-type import is not already imported or top-level defined,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2697
     *  but make an exception for two single-type imports which denote the same type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2698
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2699
     *  @param sym           The symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2700
     *  @param s             The scope
06bc494ca11e Initial load
duke
parents:
diff changeset
  2701
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2702
    boolean checkUniqueImport(DiagnosticPosition pos, Symbol sym, Scope s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2703
        return checkUniqueImport(pos, sym, s, false);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2704
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2705
06bc494ca11e Initial load
duke
parents:
diff changeset
  2706
    /** Check that static single-type import is not already imported or top-level defined,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2707
     *  but make an exception for two single-type imports which denote the same type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2708
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2709
     *  @param sym           The symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2710
     *  @param s             The scope
06bc494ca11e Initial load
duke
parents:
diff changeset
  2711
     *  @param staticImport  Whether or not this was a static import
06bc494ca11e Initial load
duke
parents:
diff changeset
  2712
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2713
    boolean checkUniqueStaticImport(DiagnosticPosition pos, Symbol sym, Scope s) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2714
        return checkUniqueImport(pos, sym, s, true);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2715
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2716
06bc494ca11e Initial load
duke
parents:
diff changeset
  2717
    /** Check that single-type import is not already imported or top-level defined,
06bc494ca11e Initial load
duke
parents:
diff changeset
  2718
     *  but make an exception for two single-type imports which denote the same type.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2719
     *  @param pos           Position for error reporting.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2720
     *  @param sym           The symbol.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2721
     *  @param s             The scope.
06bc494ca11e Initial load
duke
parents:
diff changeset
  2722
     *  @param staticImport  Whether or not this was a static import
06bc494ca11e Initial load
duke
parents:
diff changeset
  2723
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2724
    private boolean checkUniqueImport(DiagnosticPosition pos, Symbol sym, Scope s, boolean staticImport) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2725
        for (Scope.Entry e = s.lookup(sym.name); e.scope != null; e = e.next()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2726
            // is encountered class entered via a class declaration?
06bc494ca11e Initial load
duke
parents:
diff changeset
  2727
            boolean isClassDecl = e.scope == s;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2728
            if ((isClassDecl || sym != e.sym) &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2729
                sym.kind == e.sym.kind &&
06bc494ca11e Initial load
duke
parents:
diff changeset
  2730
                sym.name != names.error) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2731
                if (!e.sym.type.isErroneous()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2732
                    String what = e.sym.toString();
06bc494ca11e Initial load
duke
parents:
diff changeset
  2733
                    if (!isClassDecl) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2734
                        if (staticImport)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2735
                            log.error(pos, "already.defined.static.single.import", what);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2736
                        else
06bc494ca11e Initial load
duke
parents:
diff changeset
  2737
                            log.error(pos, "already.defined.single.import", what);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2738
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2739
                    else if (sym != e.sym)
06bc494ca11e Initial load
duke
parents:
diff changeset
  2740
                        log.error(pos, "already.defined.this.unit", what);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2741
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2742
                return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2743
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2744
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2745
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2746
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2747
06bc494ca11e Initial load
duke
parents:
diff changeset
  2748
    /** Check that a qualified name is in canonical form (for import decls).
06bc494ca11e Initial load
duke
parents:
diff changeset
  2749
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  2750
    public void checkCanonical(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2751
        if (!isCanonical(tree))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2752
            log.error(tree.pos(), "import.requires.canonical",
06bc494ca11e Initial load
duke
parents:
diff changeset
  2753
                      TreeInfo.symbol(tree));
06bc494ca11e Initial load
duke
parents:
diff changeset
  2754
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2755
        // where
06bc494ca11e Initial load
duke
parents:
diff changeset
  2756
        private boolean isCanonical(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2757
            while (tree.getTag() == JCTree.SELECT) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2758
                JCFieldAccess s = (JCFieldAccess) tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2759
                if (s.sym.owner != TreeInfo.symbol(s.selected))
06bc494ca11e Initial load
duke
parents:
diff changeset
  2760
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2761
                tree = s.selected;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2762
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2763
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2764
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2765
06bc494ca11e Initial load
duke
parents:
diff changeset
  2766
    private class ConversionWarner extends Warner {
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2767
        final String uncheckedKey;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2768
        final Type found;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2769
        final Type expected;
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2770
        public ConversionWarner(DiagnosticPosition pos, String uncheckedKey, Type found, Type expected) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2771
            super(pos);
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2772
            this.uncheckedKey = uncheckedKey;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2773
            this.found = found;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2774
            this.expected = expected;
06bc494ca11e Initial load
duke
parents:
diff changeset
  2775
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2776
3780
368edd3d2082 6874249: Check has duplicate local variable and field for "source"
jjg
parents: 3765
diff changeset
  2777
        @Override
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2778
        public void warn(LintCategory lint) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2779
            boolean warned = this.warned;
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2780
            super.warn(lint);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2781
            if (warned) return; // suppress redundant diagnostics
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2782
            switch (lint) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2783
                case UNCHECKED:
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2784
                    Check.this.warnUnchecked(pos(), "prob.found.req", diags.fragment(uncheckedKey), found, expected);
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2785
                    break;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2786
                case VARARGS:
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2787
                    if (method != null &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2788
                            method.attribute(syms.trustMeType.tsym) != null &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2789
                            isTrustMeAllowedOnMethod(method) &&
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2790
                            !types.isReifiable(method.type.getParameterTypes().last())) {
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2791
                        Check.this.warnUnsafeVararg(pos(), "varargs.unsafe.use.varargs.param", method.params.last());
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2792
                    }
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2793
                    break;
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2794
                default:
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2795
                    throw new AssertionError("Unexpected lint: " + lint);
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7628
diff changeset
  2796
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  2797
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2798
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2799
06bc494ca11e Initial load
duke
parents:
diff changeset
  2800
    public Warner castWarner(DiagnosticPosition pos, Type found, Type expected) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2801
        return new ConversionWarner(pos, "unchecked.cast.to.type", found, expected);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2802
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2803
06bc494ca11e Initial load
duke
parents:
diff changeset
  2804
    public Warner convertWarner(DiagnosticPosition pos, Type found, Type expected) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  2805
        return new ConversionWarner(pos, "unchecked.assign", found, expected);
06bc494ca11e Initial load
duke
parents:
diff changeset
  2806
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  2807
}