110 rs = Resolve.instance(context);
111 syms = Symtab.instance(context);
112 enter = Enter.instance(context);
113 deferredAttr = DeferredAttr.instance(context);
114 infer = Infer.instance(context);
115 types = Types.instance(context);
116 diags = JCDiagnostic.Factory.instance(context);
117 Options options = Options.instance(context);
118 lint = Lint.instance(context);
119 treeinfo = TreeInfo.instance(context);
120 fileManager = context.get(JavaFileManager.class);
121
122 Source source = Source.instance(context);
123 allowGenerics = source.allowGenerics();
124 allowVarargs = source.allowVarargs();
125 allowAnnotations = source.allowAnnotations();
126 allowCovariantReturns = source.allowCovariantReturns();
127 allowSimplifiedVarargs = source.allowSimplifiedVarargs();
128 allowDefaultMethods = source.allowDefaultMethods();
129 allowStrictMethodClashCheck = source.allowStrictMethodClashCheck();
130 complexInference = options.isSet("complexinference");
131 warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
132 suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
133 enableSunApiLintControl = options.isSet("enableSunApiLintControl");
134 warnOnAccessToSensitiveMembers = options.isSet("warnOnAccessToSensitiveMembers");
135
136 Target target = Target.instance(context);
137 syntheticNameChar = target.syntheticNameChar();
138
139 profile = Profile.instance(context);
140
141 boolean verboseDeprecated = lint.isEnabled(LintCategory.DEPRECATION);
142 boolean verboseUnchecked = lint.isEnabled(LintCategory.UNCHECKED);
143 boolean verboseSunApi = lint.isEnabled(LintCategory.SUNAPI);
144 boolean enforceMandatoryWarnings = source.enforceMandatoryWarnings();
145
146 deprecationHandler = new MandatoryWarningHandler(log, verboseDeprecated,
147 enforceMandatoryWarnings, "deprecated", LintCategory.DEPRECATION);
148 uncheckedHandler = new MandatoryWarningHandler(log, verboseUnchecked,
149 enforceMandatoryWarnings, "unchecked", LintCategory.UNCHECKED);
164 /** Switch: annotations enabled?
165 */
166 boolean allowAnnotations;
167
168 /** Switch: covariant returns enabled?
169 */
170 boolean allowCovariantReturns;
171
172 /** Switch: simplified varargs enabled?
173 */
174 boolean allowSimplifiedVarargs;
175
176 /** Switch: default methods enabled?
177 */
178 boolean allowDefaultMethods;
179
180 /** Switch: should unrelated return types trigger a method clash?
181 */
182 boolean allowStrictMethodClashCheck;
183
184 /** Switch: -complexinference option set?
185 */
186 boolean complexInference;
187
188 /** Character for synthetic names
189 */
190 char syntheticNameChar;
191
192 /** A table mapping flat names of all compiled classes in this run to their
193 * symbols; maintained from outside.
194 */
195 public Map<Name,ClassSymbol> compiled = new HashMap<>();
196
197 /** A handler for messages about deprecated usage.
198 */
199 private MandatoryWarningHandler deprecationHandler;
200
201 /** A handler for messages about unchecked or unsafe usage.
202 */
203 private MandatoryWarningHandler uncheckedHandler;
800 t, diags.fragment("diamond.and.explicit.params", t));
801 return types.createErrorType(t);
802 } else {
803 return t;
804 }
805 }
806
807 void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {
808 MethodSymbol m = tree.sym;
809 if (!allowSimplifiedVarargs) return;
810 boolean hasTrustMeAnno = m.attribute(syms.trustMeType.tsym) != null;
811 Type varargElemType = null;
812 if (m.isVarArgs()) {
813 varargElemType = types.elemtype(tree.params.last().type);
814 }
815 if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {
816 if (varargElemType != null) {
817 log.error(tree,
818 "varargs.invalid.trustme.anno",
819 syms.trustMeType.tsym,
820 diags.fragment("varargs.trustme.on.virtual.varargs", m));
821 } else {
822 log.error(tree,
823 "varargs.invalid.trustme.anno",
824 syms.trustMeType.tsym,
825 diags.fragment("varargs.trustme.on.non.varargs.meth", m));
826 }
827 } else if (hasTrustMeAnno && varargElemType != null &&
828 types.isReifiable(varargElemType)) {
829 warnUnsafeVararg(tree,
830 "varargs.redundant.trustme.anno",
831 syms.trustMeType.tsym,
832 diags.fragment("varargs.trustme.on.reifiable.varargs", varargElemType));
833 }
834 else if (!hasTrustMeAnno && varargElemType != null &&
835 !types.isReifiable(varargElemType)) {
836 warnUnchecked(tree.params.head.pos(), "unchecked.varargs.non.reifiable.type", varargElemType);
837 }
838 }
839 //where
840 private boolean isTrustMeAllowedOnMethod(Symbol s) {
841 return (s.flags() & VARARGS) != 0 &&
842 (s.isConstructor() ||
843 (s.flags() & (STATIC | FINAL)) != 0);
844 }
845
846 Type checkMethod(final Type mtype,
847 final Symbol sym,
848 final Env<AttrContext> env,
849 final List<JCExpression> argtrees,
850 final List<Type> argtypes,
851 final boolean useVarargs,
852 InferenceContext inferenceContext) {
853 // System.out.println("call : " + env.tree);
854 // System.out.println("method : " + owntype);
855 // System.out.println("actuals: " + argtypes);
856 if (inferenceContext.free(mtype)) {
857 inferenceContext.addFreeTypeListener(List.of(mtype), new FreeTypeListener() {
858 public void typesInferred(InferenceContext inferenceContext) {
859 checkMethod(inferenceContext.asInstType(mtype), sym, env, argtrees, argtypes, useVarargs, inferenceContext);
860 }
861 });
862 return mtype;
863 }
|
110 rs = Resolve.instance(context);
111 syms = Symtab.instance(context);
112 enter = Enter.instance(context);
113 deferredAttr = DeferredAttr.instance(context);
114 infer = Infer.instance(context);
115 types = Types.instance(context);
116 diags = JCDiagnostic.Factory.instance(context);
117 Options options = Options.instance(context);
118 lint = Lint.instance(context);
119 treeinfo = TreeInfo.instance(context);
120 fileManager = context.get(JavaFileManager.class);
121
122 Source source = Source.instance(context);
123 allowGenerics = source.allowGenerics();
124 allowVarargs = source.allowVarargs();
125 allowAnnotations = source.allowAnnotations();
126 allowCovariantReturns = source.allowCovariantReturns();
127 allowSimplifiedVarargs = source.allowSimplifiedVarargs();
128 allowDefaultMethods = source.allowDefaultMethods();
129 allowStrictMethodClashCheck = source.allowStrictMethodClashCheck();
130 allowPrivateSafeVarargs = source.allowPrivateSafeVarargs();
131 complexInference = options.isSet("complexinference");
132 warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
133 suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
134 enableSunApiLintControl = options.isSet("enableSunApiLintControl");
135 warnOnAccessToSensitiveMembers = options.isSet("warnOnAccessToSensitiveMembers");
136
137 Target target = Target.instance(context);
138 syntheticNameChar = target.syntheticNameChar();
139
140 profile = Profile.instance(context);
141
142 boolean verboseDeprecated = lint.isEnabled(LintCategory.DEPRECATION);
143 boolean verboseUnchecked = lint.isEnabled(LintCategory.UNCHECKED);
144 boolean verboseSunApi = lint.isEnabled(LintCategory.SUNAPI);
145 boolean enforceMandatoryWarnings = source.enforceMandatoryWarnings();
146
147 deprecationHandler = new MandatoryWarningHandler(log, verboseDeprecated,
148 enforceMandatoryWarnings, "deprecated", LintCategory.DEPRECATION);
149 uncheckedHandler = new MandatoryWarningHandler(log, verboseUnchecked,
150 enforceMandatoryWarnings, "unchecked", LintCategory.UNCHECKED);
165 /** Switch: annotations enabled?
166 */
167 boolean allowAnnotations;
168
169 /** Switch: covariant returns enabled?
170 */
171 boolean allowCovariantReturns;
172
173 /** Switch: simplified varargs enabled?
174 */
175 boolean allowSimplifiedVarargs;
176
177 /** Switch: default methods enabled?
178 */
179 boolean allowDefaultMethods;
180
181 /** Switch: should unrelated return types trigger a method clash?
182 */
183 boolean allowStrictMethodClashCheck;
184
185 /** Switch: can the @SafeVarargs annotation be applied to private methods?
186 */
187 boolean allowPrivateSafeVarargs;
188
189 /** Switch: -complexinference option set?
190 */
191 boolean complexInference;
192
193 /** Character for synthetic names
194 */
195 char syntheticNameChar;
196
197 /** A table mapping flat names of all compiled classes in this run to their
198 * symbols; maintained from outside.
199 */
200 public Map<Name,ClassSymbol> compiled = new HashMap<>();
201
202 /** A handler for messages about deprecated usage.
203 */
204 private MandatoryWarningHandler deprecationHandler;
205
206 /** A handler for messages about unchecked or unsafe usage.
207 */
208 private MandatoryWarningHandler uncheckedHandler;
805 t, diags.fragment("diamond.and.explicit.params", t));
806 return types.createErrorType(t);
807 } else {
808 return t;
809 }
810 }
811
812 void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {
813 MethodSymbol m = tree.sym;
814 if (!allowSimplifiedVarargs) return;
815 boolean hasTrustMeAnno = m.attribute(syms.trustMeType.tsym) != null;
816 Type varargElemType = null;
817 if (m.isVarArgs()) {
818 varargElemType = types.elemtype(tree.params.last().type);
819 }
820 if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {
821 if (varargElemType != null) {
822 log.error(tree,
823 "varargs.invalid.trustme.anno",
824 syms.trustMeType.tsym,
825 allowPrivateSafeVarargs ?
826 diags.fragment("varargs.trustme.on.virtual.varargs", m) :
827 diags.fragment("varargs.trustme.on.virtual.varargs.final.only", m));
828 } else {
829 log.error(tree,
830 "varargs.invalid.trustme.anno",
831 syms.trustMeType.tsym,
832 diags.fragment("varargs.trustme.on.non.varargs.meth", m));
833 }
834 } else if (hasTrustMeAnno && varargElemType != null &&
835 types.isReifiable(varargElemType)) {
836 warnUnsafeVararg(tree,
837 "varargs.redundant.trustme.anno",
838 syms.trustMeType.tsym,
839 diags.fragment("varargs.trustme.on.reifiable.varargs", varargElemType));
840 }
841 else if (!hasTrustMeAnno && varargElemType != null &&
842 !types.isReifiable(varargElemType)) {
843 warnUnchecked(tree.params.head.pos(), "unchecked.varargs.non.reifiable.type", varargElemType);
844 }
845 }
846 //where
847 private boolean isTrustMeAllowedOnMethod(Symbol s) {
848 return (s.flags() & VARARGS) != 0 &&
849 (s.isConstructor() ||
850 (s.flags() & (STATIC | FINAL |
851 (allowPrivateSafeVarargs ? PRIVATE : 0) )) != 0);
852 }
853
854 Type checkMethod(final Type mtype,
855 final Symbol sym,
856 final Env<AttrContext> env,
857 final List<JCExpression> argtrees,
858 final List<Type> argtypes,
859 final boolean useVarargs,
860 InferenceContext inferenceContext) {
861 // System.out.println("call : " + env.tree);
862 // System.out.println("method : " + owntype);
863 // System.out.println("actuals: " + argtypes);
864 if (inferenceContext.free(mtype)) {
865 inferenceContext.addFreeTypeListener(List.of(mtype), new FreeTypeListener() {
866 public void typesInferred(InferenceContext inferenceContext) {
867 checkMethod(inferenceContext.asInstType(mtype), sym, env, argtrees, argtypes, useVarargs, inferenceContext);
868 }
869 });
870 return mtype;
871 }
|