001 /*
002 * Copyright 2010-2013 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.jet.lang.diagnostics.rendering;
018
019 import org.jetbrains.annotations.NotNull;
020 import org.jetbrains.jet.lang.diagnostics.AbstractDiagnosticFactory;
021 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
022 import org.jetbrains.jet.lang.diagnostics.Errors;
023 import org.jetbrains.jet.lang.psi.JetExpression;
024 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
025 import org.jetbrains.jet.lang.psi.JetTypeConstraint;
026 import org.jetbrains.jet.lang.types.ErrorUtils;
027 import org.jetbrains.jet.lang.types.JetType;
028 import org.jetbrains.jet.lexer.JetKeywordToken;
029 import org.jetbrains.jet.renderer.DescriptorRenderer;
030
031 import java.lang.reflect.Field;
032 import java.lang.reflect.Modifier;
033 import java.util.Collection;
034
035 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
036 import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.*;
037
038 public class DefaultErrorMessages {
039 public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap();
040 public static final DiagnosticRenderer<Diagnostic> RENDERER = new DispatchingDiagnosticRenderer(MAP);
041
042 static {
043 MAP.put(EXCEPTION_WHILE_ANALYZING, "{0}", new Renderer<Throwable>() {
044 @NotNull
045 @Override
046 public String render(@NotNull Throwable e) {
047 return e.getClass().getSimpleName() + ": " + e.getMessage();
048 }
049 });
050
051 MAP.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", ELEMENT_TEXT);
052
053 MAP.put(INVISIBLE_REFERENCE, "Cannot access ''{0}'': it is ''{1}'' in ''{2}''", NAME, TO_STRING, NAME);
054 MAP.put(INVISIBLE_MEMBER, "Cannot access ''{0}'': it is ''{1}'' in ''{2}''", NAME, TO_STRING, NAME);
055
056 MAP.put(REDECLARATION, "Redeclaration: {0}", NAME);
057 MAP.put(NAME_SHADOWING, "Name shadowed: {0}", NAME);
058
059 MAP.put(TYPE_MISMATCH, "Type mismatch: inferred type is {1} but {0} was expected", RENDER_TYPE, RENDER_TYPE);
060 MAP.put(INCOMPATIBLE_MODIFIERS, "Incompatible modifiers: ''{0}''", new Renderer<Collection<JetKeywordToken>>() {
061 @NotNull
062 @Override
063 public String render(@NotNull Collection<JetKeywordToken> tokens) {
064 StringBuilder sb = new StringBuilder();
065 for (JetKeywordToken token : tokens) {
066 if (sb.length() != 0) {
067 sb.append(" ");
068 }
069 sb.append(token.getValue());
070 }
071 return sb.toString();
072 }
073 });
074 MAP.put(ILLEGAL_MODIFIER, "Illegal modifier ''{0}''", TO_STRING);
075
076 MAP.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", TO_STRING, TO_STRING);
077 MAP.put(ABSTRACT_MODIFIER_IN_TRAIT, "Modifier ''abstract'' is redundant in trait");
078 MAP.put(OPEN_MODIFIER_IN_TRAIT, "Modifier ''open'' is redundant in trait");
079 MAP.put(OPEN_MODIFIER_IN_ENUM, "Modifier ''open'' is not applicable for enum class");
080 MAP.put(ILLEGAL_ENUM_ANNOTATION, "Annotation ''enum'' is only applicable for class");
081 MAP.put(REDUNDANT_MODIFIER_IN_GETTER, "Visibility modifiers are redundant in getter");
082 MAP.put(TRAIT_CAN_NOT_BE_FINAL, "Trait cannot be final");
083 MAP.put(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM,
084 "Type checking has run into a recursive problem. Easiest workaround: specify types of your declarations explicitly"); // TODO: message
085 MAP.put(RETURN_NOT_ALLOWED, "'return' is not allowed here");
086 MAP.put(PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE, "Projections are not allowed for immediate arguments of a supertype");
087 MAP.put(LABEL_NAME_CLASH, "There is more than one label with such a name in this scope");
088 MAP.put(EXPRESSION_EXPECTED_NAMESPACE_FOUND, "Expression expected, but a namespace name found");
089
090 MAP.put(CANNOT_IMPORT_FROM_ELEMENT, "Cannot import from ''{0}''", NAME);
091 MAP.put(CANNOT_BE_IMPORTED, "Cannot import ''{0}'', functions and properties can be imported only from packages", NAME);
092 MAP.put(USELESS_HIDDEN_IMPORT, "Useless import, it is hidden further");
093 MAP.put(USELESS_SIMPLE_IMPORT, "Useless import, does nothing");
094 MAP.put(PLATFORM_CLASS_MAPPED_TO_KOTLIN, "This class shouldn''t be used in Kotlin. Use {0} instead.", CLASSES_OR_SEPARATED);
095
096 MAP.put(CANNOT_INFER_PARAMETER_TYPE,
097 "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation");
098
099 MAP.put(NO_BACKING_FIELD_ABSTRACT_PROPERTY, "This property doesn't have a backing field, because it's abstract");
100 MAP.put(NO_BACKING_FIELD_CUSTOM_ACCESSORS,
101 "This property doesn't have a backing field, because it has custom accessors without reference to the backing field");
102 MAP.put(INACCESSIBLE_BACKING_FIELD, "The backing field is not accessible here");
103 MAP.put(NOT_PROPERTY_BACKING_FIELD, "The referenced variable is not a property and doesn't have backing field");
104
105 MAP.put(MIXING_NAMED_AND_POSITIONED_ARGUMENTS, "Mixing named and positioned arguments in not allowed");
106 MAP.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter");
107 MAP.put(NAMED_PARAMETER_NOT_FOUND, "Cannot find a parameter with this name: {0}", ELEMENT_TEXT);
108 MAP.put(VARARG_OUTSIDE_PARENTHESES, "Passing value as a vararg is only allowed inside a parenthesized argument list");
109 MAP.put(NON_VARARG_SPREAD, "The spread operator (*foo) may only be applied in a vararg position");
110
111 MAP.put(MANY_FUNCTION_LITERAL_ARGUMENTS, "Only one function literal is allowed outside a parenthesized argument list");
112 MAP.put(PROPERTY_WITH_NO_TYPE_NO_INITIALIZER, "This property must either have a type annotation, be initialized or be delegated");
113 MAP.put(VARIABLE_WITH_NO_TYPE_NO_INITIALIZER, "This variable must either have a type annotation or be initialized");
114
115 MAP.put(INITIALIZER_REQUIRED_FOR_MULTIDECLARATION, "Initializer required for multi-declaration");
116 MAP.put(COMPONENT_FUNCTION_MISSING, "Multi-declaration initializer of type {1} must have a ''{0}()'' function", TO_STRING, RENDER_TYPE);
117 MAP.put(COMPONENT_FUNCTION_AMBIGUITY, "Function ''{0}()'' is ambiguous for this expression: {1}", TO_STRING, AMBIGUOUS_CALLS);
118 MAP.put(COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, "''{0}()'' function returns ''{1}'', but ''{2}'' is expected",
119 TO_STRING, RENDER_TYPE, RENDER_TYPE);
120
121 MAP.put(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, "This property cannot be declared abstract");
122 MAP.put(ABSTRACT_PROPERTY_WITH_INITIALIZER, "Property with initializer cannot be abstract");
123 MAP.put(ABSTRACT_PROPERTY_WITH_GETTER, "Property with getter implementation cannot be abstract");
124 MAP.put(ABSTRACT_PROPERTY_WITH_SETTER, "Property with setter implementation cannot be abstract");
125
126 MAP.put(ABSTRACT_DELEGATED_PROPERTY, "Delegated property cannot be abstract");
127 MAP.put(ACCESSOR_FOR_DELEGATED_PROPERTY, "Delegated property cannot have accessor");
128 MAP.put(DELEGATED_PROPERTY_IN_TRAIT, "Delegated properties are not allowed in traits");
129 MAP.put(LOCAL_VARIABLE_WITH_DELEGATE, "Local variables are not allowed to have delegates");
130
131 MAP.put(PACKAGE_MEMBER_CANNOT_BE_PROTECTED, "Package member cannot be protected");
132
133 MAP.put(GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY, "Getter visibility must be the same as property visibility");
134 MAP.put(BACKING_FIELD_IN_TRAIT, "Property in a trait cannot have a backing field");
135 MAP.put(MUST_BE_INITIALIZED, "Property must be initialized");
136 MAP.put(MUST_BE_INITIALIZED_OR_BE_ABSTRACT, "Property must be initialized or be abstract");
137 MAP.put(PROPERTY_INITIALIZER_IN_TRAIT, "Property initializers are not allowed in traits");
138 MAP.put(FINAL_PROPERTY_IN_TRAIT, "Abstract property in trait cannot be final");
139 MAP.put(PROPERTY_INITIALIZER_NO_BACKING_FIELD, "Initializer is not allowed here because this property has no backing field");
140 MAP.put(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, "Abstract property ''{0}'' in non-abstract class ''{1}''", NAME, NAME);
141 MAP.put(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, "Abstract function ''{0}'' in non-abstract class ''{1}''", NAME, NAME);
142 MAP.put(ABSTRACT_FUNCTION_WITH_BODY, "A function ''{0}'' with body cannot be abstract", NAME);
143 MAP.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without a body must be abstract", NAME);
144 MAP.put(FINAL_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without body cannot be final", NAME);
145
146 MAP.put(NON_MEMBER_FUNCTION_NO_BODY, "Function ''{0}'' must have a body", NAME);
147 MAP.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, "\"open\" has no effect in a final class");
148
149 MAP.put(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE, "Public or protected member should have specified type");
150
151 MAP.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, "Projections are not allowed on type arguments of functions and properties");
152 MAP.put(SUPERTYPE_NOT_INITIALIZED, "This type has a constructor, and thus must be initialized here");
153 MAP.put(NOTHING_TO_OVERRIDE, "''{0}'' overrides nothing", NAME);
154 MAP.put(VIRTUAL_MEMBER_HIDDEN, "''{0}'' hides member of supertype ''{2}'' and needs ''override'' modifier", NAME, NAME, NAME);
155
156 MAP.put(DATA_CLASS_OVERRIDE_CONFLICT, "Function ''{0}'' generated for the data class conflicts with member of supertype ''{1}''", NAME, NAME);
157
158 MAP.put(CANNOT_OVERRIDE_INVISIBLE_MEMBER, "''{0}'' cannot has no access to ''{1}'' in class {2}, so it cannot override it",
159 DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT);
160 MAP.put(CANNOT_INFER_VISIBILITY, "Cannot infer visibility. Please specify it explicitly");
161
162 MAP.put(ENUM_ENTRY_SHOULD_BE_INITIALIZED, "Missing delegation specifier ''{0}''", NAME);
163 MAP.put(ENUM_ENTRY_ILLEGAL_TYPE, "The type constructor of enum entry should be ''{0}''", NAME);
164
165 MAP.put(UNINITIALIZED_VARIABLE, "Variable ''{0}'' must be initialized", NAME);
166 MAP.put(UNINITIALIZED_PARAMETER, "Parameter ''{0}'' is uninitialized here", NAME);
167 MAP.put(UNUSED_VARIABLE, "Variable ''{0}'' is never used", NAME);
168 MAP.put(UNUSED_PARAMETER, "Parameter ''{0}'' is never used", NAME);
169 MAP.put(ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE, "Variable ''{0}'' is assigned but never accessed", NAME);
170 MAP.put(VARIABLE_WITH_REDUNDANT_INITIALIZER, "Variable ''{0}'' initializer is redundant", NAME);
171 MAP.put(UNUSED_VALUE, "The value ''{0}'' assigned to ''{1}'' is never used", ELEMENT_TEXT, TO_STRING);
172 MAP.put(UNUSED_CHANGED_VALUE, "The value changed at ''{0}'' is never used", ELEMENT_TEXT);
173 MAP.put(UNUSED_EXPRESSION, "The expression is unused");
174 MAP.put(UNUSED_FUNCTION_LITERAL, "The function literal is unused. If you mean block, you can use 'run { ... }'");
175
176 MAP.put(VAL_REASSIGNMENT, "Val cannot be reassigned", NAME);
177 MAP.put(INVISIBLE_SETTER, "Cannot assign to ''{0}'': the setter is ''{1}'' in ''{2}''", NAME, TO_STRING, NAME);
178 MAP.put(INITIALIZATION_BEFORE_DECLARATION, "Variable cannot be initialized before declaration", NAME);
179 MAP.put(VARIABLE_EXPECTED, "Variable expected");
180
181 MAP.put(VAL_OR_VAR_ON_LOOP_PARAMETER, "''{0}'' on loop parameter is not allowed", TO_STRING);
182 MAP.put(VAL_OR_VAR_ON_FUN_PARAMETER, "''{0}'' on function parameter is not allowed", TO_STRING);
183 MAP.put(VAL_OR_VAR_ON_CATCH_PARAMETER, "''{0}'' on catch parameter is not allowed", TO_STRING);
184
185 MAP.put(INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER,
186 "This property has a custom setter, so initialization using backing field required", NAME);
187 MAP.put(INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER,
188 "Setter of this property can be overridden, so initialization using backing field required", NAME);
189
190 MAP.put(UNREACHABLE_CODE, "Unreachable code");
191
192 MAP.put(MANY_CLASS_OBJECTS, "Only one class object is allowed per class");
193 MAP.put(CLASS_OBJECT_NOT_ALLOWED, "A class object is not allowed here");
194 MAP.put(DELEGATION_IN_TRAIT, "Traits cannot use delegation");
195 MAP.put(DELEGATION_NOT_TO_TRAIT, "Only traits can be delegated to");
196 MAP.put(NO_CONSTRUCTOR, "This class does not have a constructor");
197 MAP.put(NOT_A_CLASS, "Not a class");
198 MAP.put(ILLEGAL_ESCAPE_SEQUENCE, "Illegal escape sequence");
199
200 MAP.put(LOCAL_EXTENSION_PROPERTY, "Local extension properties are not allowed");
201 MAP.put(LOCAL_VARIABLE_WITH_GETTER, "Local variables are not allowed to have getters");
202 MAP.put(LOCAL_VARIABLE_WITH_SETTER, "Local variables are not allowed to have setters");
203 MAP.put(VAL_WITH_SETTER, "A 'val'-property cannot have a setter");
204
205 MAP.put(NO_GET_METHOD, "No get method providing array access");
206 MAP.put(NO_SET_METHOD, "No set method providing array access");
207
208 MAP.put(INC_DEC_SHOULD_NOT_RETURN_UNIT, "Functions inc(), dec() shouldn't return Unit to be used by operators ++, --");
209 MAP.put(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT, "Function ''{0}'' should return Unit to be used by corresponding operator ''{1}''",
210 NAME, ELEMENT_TEXT);
211 MAP.put(ASSIGN_OPERATOR_AMBIGUITY, "Assignment operators ambiguity: {0}", AMBIGUOUS_CALLS);
212
213 MAP.put(EQUALS_MISSING, "No method 'equals(jet.Any?) : jet.Boolean' available");
214 MAP.put(ASSIGNMENT_IN_EXPRESSION_CONTEXT, "Assignments are not expressions, and only expressions are allowed in this context");
215 MAP.put(NAMESPACE_IS_NOT_AN_EXPRESSION, "'namespace' is not an expression, it can only be used on the left-hand side of a dot ('.')");
216 MAP.put(SUPER_IS_NOT_AN_EXPRESSION, "''{0}'' is not an expression, it can only be used on the left-hand side of a dot ('.')", TO_STRING);
217 MAP.put(DECLARATION_IN_ILLEGAL_CONTEXT, "Declarations are not allowed in this position");
218 MAP.put(SETTER_PARAMETER_WITH_DEFAULT_VALUE, "Setter parameters cannot have default values");
219 MAP.put(NO_THIS, "'this' is not defined in this context");
220 MAP.put(SUPER_NOT_AVAILABLE, "No supertypes are accessible in this context");
221 MAP.put(SUPERCLASS_NOT_ACCESSIBLE_FROM_TRAIT, "Superclass is not accessible from trait");
222 MAP.put(AMBIGUOUS_SUPER, "Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super<Foo>'");
223 MAP.put(ABSTRACT_SUPER_CALL, "Abstract member cannot be accessed directly");
224 MAP.put(NOT_A_SUPERTYPE, "Not a supertype");
225 MAP.put(TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER, "Type arguments do not need to be specified in a 'super' qualifier");
226 MAP.put(USELESS_CAST_STATIC_ASSERT_IS_FINE, "No cast needed, use ':' instead");
227 MAP.put(USELESS_CAST, "No cast needed");
228 MAP.put(CAST_NEVER_SUCCEEDS, "This cast can never succeed");
229 MAP.put(USELESS_NULLABLE_CHECK, "Non-null type is checked for instance of nullable type");
230 MAP.put(WRONG_SETTER_PARAMETER_TYPE, "Setter parameter type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE);
231 MAP.put(WRONG_GETTER_RETURN_TYPE, "Getter return type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE);
232 MAP.put(NO_CLASS_OBJECT, "Please specify constructor invocation; classifier ''{0}'' does not have a class object", NAME);
233 MAP.put(TYPE_PARAMETER_IS_NOT_AN_EXPRESSION, "Type parameter ''{0}'' is not an expression", NAME);
234 MAP.put(TYPE_PARAMETER_ON_LHS_OF_DOT, "Type parameter ''{0}'' cannot have or inherit a class object, so it cannot be on the left hand side of dot", NAME);
235 MAP.put(NO_GENERICS_IN_SUPERTYPE_SPECIFIER, "Generic arguments of the base type must be specified");
236
237 MAP.put(INACCESSIBLE_OUTER_CLASS_EXPRESSION, "Expression is inaccessible from a nested class ''{0}'', use ''inner'' keyword to make the class inner", NAME);
238 MAP.put(NESTED_CLASS_NOT_ALLOWED, "Nested class is not allowed here, use ''inner'' keyword to make the class inner");
239
240 MAP.put(HAS_NEXT_MISSING, "hasNext() cannot be called on iterator() of type ''{0}''", RENDER_TYPE);
241 MAP.put(HAS_NEXT_FUNCTION_AMBIGUITY, "hasNext() is ambiguous for iterator() of type ''{0}''", RENDER_TYPE);
242 MAP.put(HAS_NEXT_FUNCTION_NONE_APPLICABLE, "None of the hasNext() functions is applicable for iterator() of type ''{0}''", RENDER_TYPE);
243 MAP.put(HAS_NEXT_FUNCTION_TYPE_MISMATCH, "The ''iterator().hasNext()'' function of the loop range must return jet.Boolean, but returns {0}",
244 RENDER_TYPE);
245
246 MAP.put(NEXT_MISSING, "next() cannot be called on iterator() of type ''{0}''", RENDER_TYPE);
247 MAP.put(NEXT_AMBIGUITY, "next() is ambiguous for iterator() of type ''{0}''", RENDER_TYPE);
248 MAP.put(NEXT_NONE_APPLICABLE, "None of the next() functions is applicable for iterator() of type ''{0}''", RENDER_TYPE);
249
250 MAP.put(ITERATOR_MISSING, "For-loop range must have an iterator() method");
251 MAP.put(ITERATOR_AMBIGUITY, "Method ''iterator()'' is ambiguous for this expression: {0}", AMBIGUOUS_CALLS);
252
253 MAP.put(DELEGATE_SPECIAL_FUNCTION_MISSING, "Missing ''{0}'' method on delegate of type ''{1}''", TO_STRING, RENDER_TYPE);
254 MAP.put(DELEGATE_SPECIAL_FUNCTION_AMBIGUITY, "Overload resolution ambiguity on method ''{0}'': {1}", TO_STRING, AMBIGUOUS_CALLS);
255 MAP.put(DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, "Property delegate must have a ''{0}'' method. None of the following functions is suitable: {1}", TO_STRING, AMBIGUOUS_CALLS);
256 MAP.put(DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, "The ''{0}'' function of property delegate is expected to return ''{1}'', but returns ''{2}''",
257 TO_STRING, RENDER_TYPE, RENDER_TYPE);
258
259 MAP.put(COMPARE_TO_TYPE_MISMATCH, "''compareTo()'' must return jet.Int, but returns {0}", RENDER_TYPE);
260 MAP.put(CALLEE_NOT_A_FUNCTION, "Expecting a function type, but found {0}", RENDER_TYPE);
261
262 MAP.put(RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY,
263 "Returns are not allowed for functions with expression body. Use block body in '{...}'");
264 MAP.put(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, "A 'return' expression required in a function with a block body ('{...}')");
265 MAP.put(RETURN_TYPE_MISMATCH, "This function must return a value of type {0}", RENDER_TYPE);
266 MAP.put(EXPECTED_TYPE_MISMATCH, "Expected a value of type {0}", RENDER_TYPE);
267 MAP.put(ASSIGNMENT_TYPE_MISMATCH,
268 "Expected a value of type {0}. Assignment operation is not an expression, so it does not return any value", RENDER_TYPE);
269
270 MAP.put(EXPECTED_PARAMETER_TYPE_MISMATCH, "Expected parameter of type {0}", RENDER_TYPE);
271 MAP.put(EXPECTED_RETURN_TYPE_MISMATCH, "Expected return type {0}", RENDER_TYPE);
272 MAP.put(EXPECTED_PARAMETERS_NUMBER_MISMATCH, "Expected {0,choice,0#no parameters|1#one parameter of type|1<{0,number,integer} parameters of types} {1}", null, RENDER_COLLECTION_OF_TYPES);
273
274 MAP.put(IMPLICIT_CAST_TO_UNIT_OR_ANY, "Type was casted to ''{0}''. Please specify ''{0}'' as expected type, if you mean such cast",
275 RENDER_TYPE);
276 MAP.put(EXPRESSION_EXPECTED, "{0} is not an expression, and only expressions are allowed here", new Renderer<JetExpression>() {
277 @NotNull
278 @Override
279 public String render(@NotNull JetExpression expression) {
280 String expressionType = expression.toString();
281 return expressionType.substring(0, 1) +
282 expressionType.substring(1).toLowerCase();
283 }
284 });
285
286 MAP.put(UPPER_BOUND_VIOLATED, "Type argument is not within its bounds: should be subtype of ''{0}''", RENDER_TYPE, RENDER_TYPE);
287 MAP.put(FINAL_CLASS_OBJECT_UPPER_BOUND, "''{0}'' is a final type, and thus a class object cannot extend it", RENDER_TYPE);
288 MAP.put(FINAL_UPPER_BOUND, "''{0}'' is a final type, and thus a value of the type parameter is predetermined", RENDER_TYPE);
289 MAP.put(USELESS_ELVIS, "Elvis operator (?:) always returns the left operand of non-nullable type {0}", RENDER_TYPE);
290 MAP.put(CONFLICTING_UPPER_BOUNDS, "Upper bounds of {0} have empty intersection", NAME);
291 MAP.put(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS, "Class object upper bounds of {0} have empty intersection", NAME);
292
293 MAP.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", DescriptorRenderer.TEXT);
294 MAP.put(ERROR_COMPILE_TIME_VALUE, "{0}", TO_STRING);
295
296 MAP.put(ELSE_MISPLACED_IN_WHEN, "'else' entry must be the last one in a when-expression");
297
298 MAP.put(NO_ELSE_IN_WHEN, "'when' expression must contain 'else' branch");
299 MAP.put(TYPE_MISMATCH_IN_RANGE, "Type mismatch: incompatible types of range and element checked in it");
300 MAP.put(CYCLIC_INHERITANCE_HIERARCHY, "There's a cycle in the inheritance hierarchy for this type");
301
302 MAP.put(MANY_CLASSES_IN_SUPERTYPE_LIST, "Only one class may appear in a supertype list");
303 MAP.put(SUPERTYPE_NOT_A_CLASS_OR_TRAIT, "Only classes and traits may serve as supertypes");
304 MAP.put(SUPERTYPE_INITIALIZED_IN_TRAIT, "Traits cannot initialize supertypes");
305 MAP.put(CLASS_IN_SUPERTYPE_FOR_ENUM, "Enum class cannot inherit from classes");
306 MAP.put(CONSTRUCTOR_IN_TRAIT, "A trait may not have a constructor");
307 MAP.put(SUPERTYPE_APPEARS_TWICE, "A supertype appears twice");
308 MAP.put(FINAL_SUPERTYPE, "This type is final, so it cannot be inherited from");
309
310 MAP.put(ILLEGAL_SELECTOR, "Expression ''{0}'' cannot be a selector (occur after a dot)", TO_STRING);
311
312 MAP.put(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION, "A type annotation is required on a value parameter");
313 MAP.put(BREAK_OR_CONTINUE_OUTSIDE_A_LOOP, "'break' and 'continue' are only allowed inside a loop");
314 MAP.put(NOT_A_LOOP_LABEL, "The label ''{0}'' does not denote a loop", TO_STRING);
315 MAP.put(NOT_A_RETURN_LABEL, "The label ''{0}'' does not reference to a context from which we can return", TO_STRING);
316
317 MAP.put(ANONYMOUS_INITIALIZER_IN_TRAIT, "Anonymous initializers are not allowed in traits");
318 MAP.put(NULLABLE_SUPERTYPE, "A supertype cannot be nullable");
319 MAP.put(REDUNDANT_NULLABLE, "Redundant '?'");
320 MAP.put(BASE_WITH_NULLABLE_UPPER_BOUND, "''{0}'' has a nullable upper bound. " +
321 "This means that a value of this type may be null. " +
322 "Using ''{0}?'' is likely to mislead the reader", RENDER_TYPE);
323 MAP.put(UNSAFE_CALL, "Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type {0}", RENDER_TYPE);
324 MAP.put(AMBIGUOUS_LABEL, "Ambiguous label");
325 MAP.put(UNSUPPORTED, "Unsupported [{0}]", TO_STRING);
326 MAP.put(UNNECESSARY_SAFE_CALL, "Unnecessary safe call on a non-null receiver of type {0}", RENDER_TYPE);
327 MAP.put(UNNECESSARY_NOT_NULL_ASSERTION, "Unnecessary non-null assertion (!!) on a non-null receiver of type {0}", RENDER_TYPE);
328 MAP.put(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", new Renderer<JetTypeConstraint>() {
329 @NotNull
330 @Override
331 public String render(@NotNull JetTypeConstraint typeConstraint) {
332 //noinspection ConstantConditions
333 return typeConstraint.getSubjectTypeParameterName().getReferencedName();
334 }
335 }, NAME);
336 MAP.put(AUTOCAST_IMPOSSIBLE, "Automatic cast to ''{0}'' is impossible, because ''{1}'' could have changed since the is-check", RENDER_TYPE,
337 NAME);
338
339 MAP.put(VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY, "Variance annotations are only allowed for type parameters of classes and traits");
340 MAP.put(REDUNDANT_PROJECTION, "Projection is redundant: the corresponding type parameter of {0} has the same variance", NAME);
341 MAP.put(CONFLICTING_PROJECTION, "Projection is conflicting with variance of the corresponding type parameter of {0}. Remove the projection or replace it with ''*''", NAME);
342
343 MAP.put(TYPE_MISMATCH_IN_FOR_LOOP, "The loop iterates over values of type {0} but the parameter is declared to be {1}", RENDER_TYPE,
344 RENDER_TYPE);
345 MAP.put(TYPE_MISMATCH_IN_CONDITION, "Condition must be of type jet.Boolean, but is of type {0}", RENDER_TYPE);
346 MAP.put(INCOMPATIBLE_TYPES, "Incompatible types: {0} and {1}", RENDER_TYPE, RENDER_TYPE);
347 MAP.put(EXPECTED_CONDITION, "Expected condition of jet.Boolean type");
348
349 MAP.put(CANNOT_CHECK_FOR_ERASED, "Cannot check for instance of erased type: {0}", RENDER_TYPE);
350 MAP.put(UNCHECKED_CAST, "Unchecked cast: {0} to {1}", RENDER_TYPE, RENDER_TYPE);
351
352 MAP.put(INCONSISTENT_TYPE_PARAMETER_VALUES, "Type parameter {0} of ''{1}'' has inconsistent values: {2}", NAME, NAME, RENDER_COLLECTION_OF_TYPES);
353
354 MAP.put(EQUALITY_NOT_APPLICABLE, "Operator ''{0}'' cannot be applied to ''{1}'' and ''{2}''", new Renderer<JetSimpleNameExpression>() {
355 @NotNull
356 @Override
357 public String render(@NotNull JetSimpleNameExpression nameExpression) {
358 //noinspection ConstantConditions
359 return nameExpression.getReferencedName();
360 }
361 }, RENDER_TYPE, RENDER_TYPE);
362
363 MAP.put(SENSELESS_COMPARISON, "Condition ''{0}'' is always ''{1}''", ELEMENT_TEXT, TO_STRING);
364 MAP.put(SENSELESS_NULL_IN_WHEN, "Expression under 'when' is never equal to null");
365
366 MAP.put(OVERRIDING_FINAL_MEMBER, "''{0}'' in ''{1}'' is final and cannot be overridden", NAME, NAME);
367 MAP.put(CANNOT_WEAKEN_ACCESS_PRIVILEGE, "Cannot weaken access privilege ''{0}'' for ''{1}'' in ''{2}''", TO_STRING, NAME, NAME);
368 MAP.put(CANNOT_CHANGE_ACCESS_PRIVILEGE, "Cannot change access privilege ''{0}'' for ''{1}'' in ''{2}''", TO_STRING, NAME, NAME);
369
370 MAP.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, "Return type of ''{0}'' is not a subtype of the return type of overridden member {1}",
371 NAME, DescriptorRenderer.TEXT);
372
373 MAP.put(PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, "Type of ''{0}'' doesn't match to the type of overridden var-property {1}",
374 NAME, DescriptorRenderer.TEXT);
375
376 MAP.put(VAR_OVERRIDDEN_BY_VAL, "Var-property {0} cannot be overridden by val-property {1}", DescriptorRenderer.TEXT,
377 DescriptorRenderer.TEXT);
378
379 MAP.put(ABSTRACT_MEMBER_NOT_IMPLEMENTED, "{0} must be declared abstract or implement abstract member {1}", RENDER_CLASS_OR_OBJECT,
380 DescriptorRenderer.TEXT);
381
382 MAP.put(MANY_IMPL_MEMBER_NOT_IMPLEMENTED, "{0} must override {1} because it inherits many implementations of it",
383 RENDER_CLASS_OR_OBJECT, DescriptorRenderer.TEXT);
384
385 MAP.put(CONFLICTING_OVERLOADS, "{1} is already defined in ''{0}''", DescriptorRenderer.TEXT, TO_STRING);
386
387 MAP.put(FUNCTION_EXPECTED, "Expression ''{0}''{1} cannot be invoked as a function", ELEMENT_TEXT, new Renderer<JetType>() {
388 @NotNull
389 @Override
390 public String render(@NotNull JetType type) {
391 if (ErrorUtils.isErrorType(type)) return "";
392 return " of type '" + type.toString() + "'";
393 }
394 });
395 MAP.put(FUNCTION_CALL_EXPECTED, "Function invocation ''{0}({1})'' expected", ELEMENT_TEXT,new Renderer<Boolean>() {
396 @NotNull
397 @Override
398 public String render(@NotNull Boolean hasValueParameters) {
399 return hasValueParameters ? "..." : "";
400 }
401 });
402
403
404 MAP.put(RESULT_TYPE_MISMATCH, "{0} must return {1} but returns {2}", TO_STRING, RENDER_TYPE, RENDER_TYPE);
405 MAP.put(UNSAFE_INFIX_CALL,
406 "Infix call corresponds to a dot-qualified call ''{0}.{1}({2})'' which is not allowed on a nullable receiver ''{0}''. " +
407 "Use '?.'-qualified call instead",
408 TO_STRING, TO_STRING, TO_STRING);
409
410 MAP.put(OVERLOAD_RESOLUTION_AMBIGUITY, "Overload resolution ambiguity: {0}", AMBIGUOUS_CALLS);
411 MAP.put(NONE_APPLICABLE, "None of the following functions can be called with the arguments supplied: {0}", AMBIGUOUS_CALLS);
412 MAP.put(CANNOT_COMPLETE_RESOLVE, "Cannot choose among the following candidates without completing type inference: {0}", AMBIGUOUS_CALLS);
413 MAP.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, "Unresolved reference. None of the following candidates is applicable because of receiver type mismatch: {0}", AMBIGUOUS_CALLS);
414
415 MAP.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter {0}", NAME);
416 MAP.put(MISSING_RECEIVER, "A receiver of type {0} is required", RENDER_TYPE);
417 MAP.put(NO_RECEIVER_ADMITTED, "No receiver can be passed to this function or property");
418
419 MAP.put(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, "Cannot create an instance of an abstract class");
420
421 MAP.put(TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS, "Type inference failed: {0}", TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER);
422 MAP.put(TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, "Type inference failed: {0}", TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER);
423 MAP.put(TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH, "Type inference failed: {0}", TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH_RENDERER);
424 MAP.put(TYPE_INFERENCE_UPPER_BOUND_VIOLATED, "{0}", TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER);
425 MAP.put(TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, "Type inference failed. Expected type mismatch: found: {0} required: {1}", RENDER_TYPE, RENDER_TYPE);
426
427 MAP.put(WRONG_NUMBER_OF_TYPE_ARGUMENTS, "{0,choice,0#No type arguments|1#Type argument|1<{0,number,integer} type arguments} expected", null);
428 MAP.put(NO_TYPE_ARGUMENTS_ON_RHS_OF_IS_EXPRESSION, "{0,choice,0#No type arguments|1#Type argument|1<{0,number,integer} type arguments} expected. " +
429 "Use ''{1}'' if you don''t want to pass type arguments", null, TO_STRING);
430
431 MAP.put(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED,
432 "This expression is treated as an argument to the function call on the previous line. " +
433 "Separate it with a semicolon (;) if it is not intended to be an argument.");
434
435 MAP.put(NOT_AN_ANNOTATION_CLASS, "''{0}'' is not an annotation class", TO_STRING);
436 MAP.put(ANNOTATION_CLASS_WITH_BODY, "Body is not allowed for annotation class");
437 MAP.put(INVALID_TYPE_OF_ANNOTATION_MEMBER, "Invalid type of annotation member");
438 MAP.put(NULLABLE_TYPE_OF_ANNOTATION_MEMBER, "An annotation parameter cannot be nullable");
439 MAP.put(ILLEGAL_ANNOTATION_KEYWORD, "''annotation'' keyword is only applicable for class");
440
441 MAP.put(DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE, "An overriding function is not allowed to specify default values for its parameters");
442
443
444 String multipleDefaultsMessage = "More than one overridden descriptor declares a default value for ''{0}''. " +
445 "As the compiler can not make sure these values agree, this is not allowed.";
446 MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES, multipleDefaultsMessage, TO_STRING);
447 MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, multipleDefaultsMessage, TO_STRING);
448
449 MAP.put(PARAMETER_NAME_CHANGED_ON_OVERRIDE, "The corresponding parameter in the supertype ''{0}'' is named ''{1}''. " +
450 "This may cause problems when calling this function with named arguments.", NAME, NAME);
451
452 MAP.put(DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES,
453 "Names of the parameter #{1} conflict in the following members of supertypes: ''{0}''" +
454 "This may cause problems when calling this function with named arguments.", commaSeparated(TO_STRING), TO_STRING);
455
456 MAP.put(AMBIGUOUS_ANONYMOUS_TYPE_INFERRED, "Right-hand side has anonymous type. Please specify type explicitly", TO_STRING);
457
458 MAP.put(EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED,
459 "''{0}'' is a member and an extension at the same time. References to such elements are not allowed", TO_STRING);
460 MAP.put(CALLABLE_REFERENCE_LHS_NOT_A_CLASS, "Callable reference left-hand side cannot be a type parameter");
461
462 MAP.setImmutable();
463
464 for (Field field : Errors.class.getFields()) {
465 if (Modifier.isStatic(field.getModifiers())) {
466 try {
467 Object fieldValue = field.get(null);
468 if (fieldValue instanceof AbstractDiagnosticFactory) {
469 if (MAP.get((AbstractDiagnosticFactory) fieldValue) == null) {
470 throw new IllegalStateException("No default diagnostic renderer is provided for " + ((AbstractDiagnosticFactory)fieldValue).getName());
471 }
472 }
473 }
474 catch (IllegalAccessException e) {
475 throw new IllegalStateException(e);
476 }
477 }
478 }
479 }
480
481 private DefaultErrorMessages() {
482 }
483 }