1 /*
   2  * Copyright (c) 2002, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.code;
  27 
  28 import java.util.*;
  29 
  30 import javax.lang.model.SourceVersion;
  31 import static javax.lang.model.SourceVersion.*;
  32 
  33 import com.sun.tools.javac.jvm.Target;
  34 import com.sun.tools.javac.resources.CompilerProperties.Errors;
  35 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
  36 import com.sun.tools.javac.util.*;
  37 import com.sun.tools.javac.util.JCDiagnostic.Error;
  38 import com.sun.tools.javac.util.JCDiagnostic.Fragment;
  39 
  40 import static com.sun.tools.javac.main.Option.*;
  41 
  42 /** The source language version accepted.
  43  *
  44  *  <p><b>This is NOT part of any supported API.
  45  *  If you write code that depends on this, you do so at your own risk.
  46  *  This code and its internal interfaces are subject to change or
  47  *  deletion without notice.</b>
  48  */
  49 public enum Source {
  50     /** 1.0 had no inner classes, and so could not pass the JCK. */
  51     // public static final Source JDK1_0 =              new Source("1.0");
  52 
  53     /** 1.1 did not have strictfp, and so could not pass the JCK. */
  54     // public static final Source JDK1_1 =              new Source("1.1");
  55 
  56     /** 1.2 introduced strictfp. */
  57     JDK1_2("1.2"),
  58 
  59     /** 1.3 is the same language as 1.2. */
  60     JDK1_3("1.3"),
  61 
  62     /** 1.4 introduced assert. */
  63     JDK1_4("1.4"),
  64 
  65     /** 1.5 introduced generics, attributes, foreach, boxing, static import,
  66      *  covariant return, enums, varargs, et al. */
  67     JDK5("5"),
  68 
  69     /** 1.6 reports encoding problems as errors instead of warnings. */
  70     JDK6("6"),
  71 
  72     /** 1.7 introduced try-with-resources, multi-catch, string switch, etc. */
  73     JDK7("7"),
  74 
  75     /** 1.8 lambda expressions and default methods. */
  76     JDK8("8"),
  77 
  78     /** 1.9 modularity. */
  79     JDK9("9"),
  80 
  81     /** 1.10 local-variable type inference (var). */
  82     JDK10("10"),
  83 
  84     /** 1.11 local-variable syntax for lambda parameters */
  85     JDK11("11"),
  86 
  87     /** 12, no language features; switch expression were in preview */
  88     JDK12("12"),
  89 
  90     /**
  91      * 13, no language features; text blocks and revised switch
  92      * expressions in preview
  93      */
  94     JDK13("13"),
  95 
  96     /**
  97      * 14 covers the to be determined language features that will be
  98      * added in JDK 14.
  99      */
 100     JDK14("14");
 101 
 102     private static final Context.Key<Source> sourceKey = new Context.Key<>();
 103 
 104     public static Source instance(Context context) {
 105         Source instance = context.get(sourceKey);
 106         if (instance == null) {
 107             Options options = Options.instance(context);
 108             String sourceString = options.get(SOURCE);
 109             if (sourceString != null) instance = lookup(sourceString);
 110             if (instance == null) instance = DEFAULT;
 111             context.put(sourceKey, instance);
 112         }
 113         return instance;
 114     }
 115 
 116     public final String name;
 117 
 118     private static final Map<String,Source> tab = new HashMap<>();
 119     static {
 120         for (Source s : values()) {
 121             tab.put(s.name, s);
 122         }
 123         tab.put("1.5", JDK5); // Make 5 an alias for 1.5
 124         tab.put("1.6", JDK6); // Make 6 an alias for 1.6
 125         tab.put("1.7", JDK7); // Make 7 an alias for 1.7
 126         tab.put("1.8", JDK8); // Make 8 an alias for 1.8
 127         tab.put("1.9", JDK9); // Make 9 an alias for 1.9
 128         tab.put("1.10", JDK10); // Make 10 an alias for 1.10
 129         // Decline to make 1.11 an alias for 11.
 130     }
 131 
 132     private Source(String name) {
 133         this.name = name;
 134     }
 135 
 136     public static final Source MIN = Source.JDK7;
 137 
 138     private static final Source MAX = values()[values().length - 1];
 139 
 140     public static final Source DEFAULT = MAX;
 141 
 142     public static Source lookup(String name) {
 143         return tab.get(name);
 144     }
 145 
 146     public boolean isSupported() {
 147         return this.compareTo(MIN) >= 0;
 148     }
 149 
 150     public Target requiredTarget() {
 151         if (this.compareTo(JDK14) >= 0) return Target.JDK1_14;
 152         if (this.compareTo(JDK13) >= 0) return Target.JDK1_13;
 153         if (this.compareTo(JDK12) >= 0) return Target.JDK1_12;
 154         if (this.compareTo(JDK11) >= 0) return Target.JDK1_11;
 155         if (this.compareTo(JDK10) >= 0) return Target.JDK1_10;
 156         if (this.compareTo(JDK9) >= 0) return Target.JDK1_9;
 157         if (this.compareTo(JDK8) >= 0) return Target.JDK1_8;
 158         if (this.compareTo(JDK7) >= 0) return Target.JDK1_7;
 159         if (this.compareTo(JDK6) >= 0) return Target.JDK1_6;
 160         if (this.compareTo(JDK5) >= 0) return Target.JDK1_5;
 161         if (this.compareTo(JDK1_4) >= 0) return Target.JDK1_4;
 162         return Target.JDK1_1;
 163     }
 164 
 165     /**
 166      * Models a feature of the Java programming language. Each feature can be associated with a
 167      * minimum source level, a maximum source level and a diagnostic fragment describing the feature,
 168      * which is used to generate error messages of the kind {@code feature XYZ not supported in source N}.
 169      */
 170     public enum Feature {
 171 
 172         DIAMOND(JDK7, Fragments.FeatureDiamond, DiagKind.NORMAL),
 173         MODULES(JDK9, Fragments.FeatureModules, DiagKind.PLURAL),
 174         EFFECTIVELY_FINAL_VARIABLES_IN_TRY_WITH_RESOURCES(JDK9, Fragments.FeatureVarInTryWithResources, DiagKind.PLURAL),
 175         DEPRECATION_ON_IMPORT(MIN, JDK8),
 176         POLY(JDK8),
 177         LAMBDA(JDK8, Fragments.FeatureLambda, DiagKind.PLURAL),
 178         METHOD_REFERENCES(JDK8, Fragments.FeatureMethodReferences, DiagKind.PLURAL),
 179         DEFAULT_METHODS(JDK8, Fragments.FeatureDefaultMethods, DiagKind.PLURAL),
 180         STATIC_INTERFACE_METHODS(JDK8, Fragments.FeatureStaticIntfMethods, DiagKind.PLURAL),
 181         STATIC_INTERFACE_METHODS_INVOKE(JDK8, Fragments.FeatureStaticIntfMethodInvoke, DiagKind.PLURAL),
 182         STRICT_METHOD_CLASH_CHECK(JDK8),
 183         EFFECTIVELY_FINAL_IN_INNER_CLASSES(JDK8),
 184         TYPE_ANNOTATIONS(JDK8, Fragments.FeatureTypeAnnotations, DiagKind.PLURAL),
 185         ANNOTATIONS_AFTER_TYPE_PARAMS(JDK8, Fragments.FeatureAnnotationsAfterTypeParams, DiagKind.PLURAL),
 186         REPEATED_ANNOTATIONS(JDK8, Fragments.FeatureRepeatableAnnotations, DiagKind.PLURAL),
 187         INTERSECTION_TYPES_IN_CAST(JDK8, Fragments.FeatureIntersectionTypesInCast, DiagKind.PLURAL),
 188         GRAPH_INFERENCE(JDK8),
 189         FUNCTIONAL_INTERFACE_MOST_SPECIFIC(JDK8),
 190         POST_APPLICABILITY_VARARGS_ACCESS_CHECK(JDK8),
 191         MAP_CAPTURES_TO_BOUNDS(MIN, JDK7),
 192         PRIVATE_SAFE_VARARGS(JDK9),
 193         DIAMOND_WITH_ANONYMOUS_CLASS_CREATION(JDK9, Fragments.FeatureDiamondAndAnonClass, DiagKind.NORMAL),
 194         UNDERSCORE_IDENTIFIER(MIN, JDK8),
 195         PRIVATE_INTERFACE_METHODS(JDK9, Fragments.FeaturePrivateIntfMethods, DiagKind.PLURAL),
 196         LOCAL_VARIABLE_TYPE_INFERENCE(JDK10),
 197         VAR_SYNTAX_IMPLICIT_LAMBDAS(JDK11, Fragments.FeatureVarSyntaxInImplicitLambda, DiagKind.PLURAL),
 198         IMPORT_ON_DEMAND_OBSERVABLE_PACKAGES(JDK1_2, JDK8),
 199         SWITCH_MULTIPLE_CASE_LABELS(JDK14, Fragments.FeatureMultipleCaseLabels, DiagKind.PLURAL),
 200         SWITCH_RULE(JDK14, Fragments.FeatureSwitchRules, DiagKind.PLURAL),
 201         SWITCH_EXPRESSION(JDK14, Fragments.FeatureSwitchExpressions, DiagKind.PLURAL),
 202         TEXT_BLOCKS(JDK14, Fragments.FeatureTextBlocks, DiagKind.PLURAL),
 203         SEALED(JDK14, Fragments.FeatureSealedTypes, DiagKind.PLURAL),
 204         RECORDS(JDK14);
 205 
 206         enum DiagKind {
 207             NORMAL,
 208             PLURAL;
 209         }
 210 
 211         private final Source minLevel;
 212         private final Source maxLevel;
 213         private final Fragment optFragment;
 214         private final DiagKind optKind;
 215 
 216         Feature(Source minLevel) {
 217             this(minLevel, null, null);
 218         }
 219 
 220         Feature(Source minLevel, Fragment optFragment, DiagKind optKind) {
 221             this(minLevel, MAX, optFragment, optKind);
 222         }
 223 
 224         Feature(Source minLevel, Source maxLevel) {
 225             this(minLevel, maxLevel, null, null);
 226         }
 227 
 228         Feature(Source minLevel, Source maxLevel, Fragment optFragment, DiagKind optKind) {
 229             this.minLevel = minLevel;
 230             this.maxLevel = maxLevel;
 231             this.optFragment = optFragment;
 232             this.optKind = optKind;
 233         }
 234 
 235         public boolean allowedInSource(Source source) {
 236             return source.compareTo(minLevel) >= 0 &&
 237                     source.compareTo(maxLevel) <= 0;
 238         }
 239 
 240         public boolean isPlural() {
 241             Assert.checkNonNull(optKind);
 242             return optKind == DiagKind.PLURAL;
 243         }
 244 
 245         public Fragment nameFragment() {
 246             Assert.checkNonNull(optFragment);
 247             return optFragment;
 248         }
 249 
 250         public Fragment fragment(String sourceName) {
 251             Assert.checkNonNull(optFragment);
 252             return optKind == DiagKind.NORMAL ?
 253                     Fragments.FeatureNotSupportedInSource(optFragment, sourceName, minLevel.name) :
 254                     Fragments.FeatureNotSupportedInSourcePlural(optFragment, sourceName, minLevel.name);
 255         }
 256 
 257         public Error error(String sourceName) {
 258             Assert.checkNonNull(optFragment);
 259             return optKind == DiagKind.NORMAL ?
 260                     Errors.FeatureNotSupportedInSource(optFragment, sourceName, minLevel.name) :
 261                     Errors.FeatureNotSupportedInSourcePlural(optFragment, sourceName, minLevel.name);
 262         }
 263     }
 264 
 265     public static SourceVersion toSourceVersion(Source source) {
 266         switch(source) {
 267         case JDK1_2:
 268             return RELEASE_2;
 269         case JDK1_3:
 270             return RELEASE_3;
 271         case JDK1_4:
 272             return RELEASE_4;
 273         case JDK5:
 274             return RELEASE_5;
 275         case JDK6:
 276             return RELEASE_6;
 277         case JDK7:
 278             return RELEASE_7;
 279         case JDK8:
 280             return RELEASE_8;
 281         case JDK9:
 282             return RELEASE_9;
 283         case JDK10:
 284             return RELEASE_10;
 285         case JDK11:
 286             return RELEASE_11;
 287         case JDK12:
 288             return RELEASE_12;
 289         case JDK13:
 290             return RELEASE_13;
 291         case JDK14:
 292             return RELEASE_14;
 293         default:
 294             return null;
 295         }
 296     }
 297 }