From 96db2ecabd3755501c24046526cafb9e28678d1d Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 12 Sep 2013 17:25:59 +0400 Subject: [PATCH] added different errors instead of ERROR_COMPILE_TIME_VALUE with different text check type for constants in DataFlowUtils --- .../jet/lang/cfg/JetControlFlowProcessor.java | 3 +- .../jet/lang/diagnostics/Errors.java | 9 +- .../rendering/DefaultErrorMessages.java | 10 +- .../lang/resolve/calls/CandidateResolver.java | 9 -- .../CompileTimeConstantResolver.java | 148 ++++++++++++------ .../lang/resolve/constants/ErrorValue.java | 71 ++++++--- .../BasicExpressionTypingVisitor.java | 28 ++-- .../lang/types/expressions/DataFlowUtils.java | 12 ++ .../expressions/ExpressionTypingUtils.java | 2 +- .../diagnostics/tests/CharacterLiterals.kt | 10 +- .../testData/diagnostics/tests/Constants.kt | 18 +-- .../tests/IncorrectCharacterLiterals.kt | 34 ++-- .../diagnostics/tests/ResolveToJava.kt | 2 +- .../diagnostics/tests/StringTemplates.kt | 4 +- .../testData/diagnostics/tests/Varargs.kt | 2 +- .../checkArguments/kt1897_diagnostic_part.kt | 12 +- .../tests/inference/regressions/kt2838.kt | 2 +- ...gumentsNullability-NotNull-SpecialTypes.kt | 2 +- ...eArgumentsNullability-NotNull-UserTypes.kt | 2 +- .../tests/numbers/intValuesOutOfRange.kt | 8 +- .../numbers/numbersInSimpleConstraints.kt | 4 +- .../TypeMismatchOnUnaryOperations.kt | 6 +- .../diagnostics/tests/regressions/kt411.kt | 2 +- .../jet/checkers/CheckerTestUtilTest.java | 2 +- .../AnnotationDescriptorDeserializer.java | 4 +- .../jet/plugin/highlighter/JetPsiChecker.java | 2 +- .../afterObjectInsideBody.kt | 2 +- .../beforeObjectInsideBody.kt | 2 +- ...terComponentFunctionReturnTypeMismatch4.kt | 2 +- ...oreComponentFunctionReturnTypeMismatch4.kt | 2 +- 30 files changed, 258 insertions(+), 158 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java index 32004fb26b4..036b32d33e6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java @@ -462,7 +462,8 @@ public class JetControlFlowProcessor { } boolean conditionIsTrueConstant = false; if (condition instanceof JetConstantExpression && condition.getNode().getElementType() == JetNodeTypes.BOOLEAN_CONSTANT) { - if (BooleanValue.TRUE == new CompileTimeConstantResolver().getBooleanValue(condition.getText(), KotlinBuiltIns.getInstance().getBooleanType())) { + if (BooleanValue.TRUE == new CompileTimeConstantResolver().getBooleanValue( + (JetConstantExpression) condition, KotlinBuiltIns.getInstance().getBooleanType())) { conditionIsTrueConstant = true; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index ca6e0c9e926..164dc93afc3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -462,7 +462,14 @@ public interface Errors { // Compile-time values - DiagnosticFactory1 ERROR_COMPILE_TIME_VALUE = DiagnosticFactory1.create(ERROR); + DiagnosticFactory0 INT_LITERAL_OUT_OF_RANGE = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 FLOAT_LITERAL_OUT_OF_RANGE = DiagnosticFactory0.create(ERROR); + DiagnosticFactory2 CONSTANT_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR); + DiagnosticFactory0 INCORRECT_CHARACTER_LITERAL = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 EMPTY_CHARACTER_LITERAL = DiagnosticFactory0.create(ERROR); + DiagnosticFactory1 TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 ILLEGAL_ESCAPE = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 NULL_FOR_NONNULL_TYPE = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 ILLEGAL_ESCAPE_SEQUENCE = DiagnosticFactory0.create(ERROR); // Casts and is-checks diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java index 58928a09bb1..4f49d7c5414 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java @@ -292,7 +292,15 @@ public class DefaultErrorMessages { MAP.put(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS, "Class object upper bounds of {0} have empty intersection", NAME); MAP.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", DescriptorRenderer.TEXT); - MAP.put(ERROR_COMPILE_TIME_VALUE, "{0}", TO_STRING); + + MAP.put(CONSTANT_EXPECTED_TYPE_MISMATCH, "An {0} literal does not conform to the expected type {1}", TO_STRING, RENDER_TYPE); + MAP.put(INT_LITERAL_OUT_OF_RANGE, "The value is out of range"); + MAP.put(FLOAT_LITERAL_OUT_OF_RANGE, "The value is out of range"); + MAP.put(INCORRECT_CHARACTER_LITERAL, "Incorrect character literal"); + MAP.put(EMPTY_CHARACTER_LITERAL, "Empty character literal"); + MAP.put(TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL, "Too many characters in a character literal ''{0}''", ELEMENT_TEXT); + MAP.put(ILLEGAL_ESCAPE, "Illegal escape: ''{0}''", ELEMENT_TEXT); + MAP.put(NULL_FOR_NONNULL_TYPE, "Null can not be a value of a non-null type {0}", RENDER_TYPE); MAP.put(ELSE_MISPLACED_IN_WHEN, "'else' entry must be the last one in a when-expression"); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index d8655c09a74..690a1047d33 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java @@ -42,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; -import org.jetbrains.jet.lang.resolve.constants.ErrorValue; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.*; @@ -441,14 +440,6 @@ public class CandidateResolver { JetExpression expression = argument.getArgumentExpression(); if (expression == null) return; - if (expression instanceof JetConstantExpression && !KotlinBuiltIns.getInstance().isUnit(context.expectedType)) { - CompileTimeConstant value = - new CompileTimeConstantResolver().getCompileTimeConstant((JetConstantExpression) expression, context.expectedType); - if (value instanceof ErrorValue) { - context.trace.report(ERROR_COMPILE_TIME_VALUE.on(expression, ((ErrorValue) value).getMessage())); - } - return; - } DataFlowInfo dataFlowInfoForValueArgument = context.candidateCall.getDataFlowInfoForArguments().getInfo(argument); ResolutionContext newContext = context.replaceExpectedType(context.expectedType).replaceDataFlowInfo(dataFlowInfoForValueArgument); DataFlowUtils.checkType(type, expression, newContext); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java index 312febc7ea6..95180e47926 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java @@ -17,11 +17,15 @@ package org.jetbrains.jet.lang.resolve.constants; import com.google.common.base.Function; +import com.google.common.collect.Sets; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetNodeTypes; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.diagnostics.AbstractDiagnosticFactory; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.JetConstantExpression; +import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeConstructor; @@ -29,40 +33,58 @@ import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import java.util.List; +import java.util.Set; + +import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.resolve.constants.ErrorValue.ErrorValueWithDiagnostic; public class CompileTimeConstantResolver { - public static final ErrorValue OUT_OF_RANGE = new ErrorValue("The value is out of range"); - private final KotlinBuiltIns builtIns; public CompileTimeConstantResolver() { this.builtIns = KotlinBuiltIns.getInstance(); } + @Nullable + public Diagnostic checkConstantExpressionType( + @NotNull JetConstantExpression expression, + @NotNull JetType expectedType + ) { + CompileTimeConstant compileTimeConstant = getCompileTimeConstant(expression, expectedType); + Set errorsThatDependOnExpectedType = + Sets.newHashSet(CONSTANT_EXPECTED_TYPE_MISMATCH, NULL_FOR_NONNULL_TYPE); + + if (compileTimeConstant instanceof ErrorValueWithDiagnostic) { + Diagnostic diagnostic = ((ErrorValueWithDiagnostic) compileTimeConstant).getDiagnostic(); + if (errorsThatDependOnExpectedType.contains(diagnostic.getFactory())) { + return diagnostic; + } + } + return null; + } + @NotNull public CompileTimeConstant getCompileTimeConstant( @NotNull JetConstantExpression expression, @NotNull JetType expectedType ) { IElementType elementType = expression.getNode().getElementType(); - String text = expression.getNode().getText(); CompileTimeConstant value; if (elementType == JetNodeTypes.INTEGER_CONSTANT) { - value = getIntegerValue(text, expectedType); + value = getIntegerValue(expression, expectedType); } else if (elementType == JetNodeTypes.FLOAT_CONSTANT) { - value = getFloatValue(text, expectedType); + value = getFloatValue(expression, expectedType); } else if (elementType == JetNodeTypes.BOOLEAN_CONSTANT) { - value = getBooleanValue(text, expectedType); + value = getBooleanValue(expression, expectedType); } else if (elementType == JetNodeTypes.CHARACTER_CONSTANT) { - value = getCharValue(text, expectedType); + value = getCharValue(expression, expectedType); } else if (elementType == JetNodeTypes.NULL) { - value = getNullValue(expectedType); + value = getNullValue(expression, expectedType); } else { throw new IllegalArgumentException("Unsupported constant: " + expression); @@ -70,16 +92,22 @@ public class CompileTimeConstantResolver { return value; } - @NotNull - public CompileTimeConstant getIntegerValue(@NotNull String text, @NotNull JetType expectedType) { - return getIntegerValue(parseLongValue(text), expectedType); + public CompileTimeConstant getIntegerValue( + @NotNull JetConstantExpression expression, @NotNull JetType expectedType + ) { + String text = expression.getText(); + return getIntegerValue(parseLongValue(text), expectedType, expression); } @NotNull - public CompileTimeConstant getIntegerValue(@Nullable Long value, @NotNull JetType expectedType) { + public CompileTimeConstant getIntegerValue( + @Nullable Long value, + @NotNull JetType expectedType, + @NotNull JetConstantExpression expression + ) { if (value == null) { - return OUT_OF_RANGE; + return ErrorValue.create(INT_LITERAL_OUT_OF_RANGE.on(expression)); } if (noExpectedTypeOrUnitOrError(expectedType)) { if (Integer.MIN_VALUE <= value && value <= Integer.MAX_VALUE) { @@ -116,20 +144,20 @@ public class CompileTimeConstantResolver { JetType intType = builtIns.getIntType(); JetType longType = builtIns.getLongType(); if (typeChecker.isSubtypeOf(intType, expectedType)) { - return getIntegerValue(value, intType); + return getIntegerValue(value, intType, expression); } else if (typeChecker.isSubtypeOf(longType, expectedType)) { - return getIntegerValue(value, longType); + return getIntegerValue(value, longType, expression); } else { - return new ErrorValue("An integer literal does not conform to the expected type " + expectedType); + return ErrorValue.create(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "integer", expectedType)); } } if (value != null && lowerBound <= value && value <= upperBound) { return create.apply(value); } - return new ErrorValue("An integer literal does not conform to the expected type " + expectedType); + return ErrorValue.create(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "integer", expectedType)); } @Nullable @@ -165,41 +193,48 @@ public class CompileTimeConstantResolver { } @NotNull - public CompileTimeConstant getFloatValue(@NotNull String text, @NotNull JetType expectedType) { - if (noExpectedTypeOrUnitOrError(expectedType) - || JetTypeChecker.INSTANCE.isSubtypeOf(builtIns.getDoubleType(), expectedType)) { - try { + public CompileTimeConstant getFloatValue( + @NotNull JetConstantExpression expression, @NotNull JetType expectedType + ) { + String text = expression.getText(); + try { + if (noExpectedTypeOrUnitOrError(expectedType) + || JetTypeChecker.INSTANCE.isSubtypeOf(builtIns.getDoubleType(), expectedType)) { return new DoubleValue(Double.parseDouble(text)); } - catch (NumberFormatException e) { - return OUT_OF_RANGE; - } - } - else if (JetTypeChecker.INSTANCE.isSubtypeOf(builtIns.getFloatType(), expectedType)) { - try { + else if (JetTypeChecker.INSTANCE.isSubtypeOf(builtIns.getFloatType(), expectedType)) { return new FloatValue(Float.parseFloat(text)); } - catch (NumberFormatException e) { - return OUT_OF_RANGE; + else { + return ErrorValue.create(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "floating-point", expectedType)); } } - else { - return new ErrorValue("A floating-point literal does not conform to the expected type " + expectedType); + catch (NumberFormatException e) { + return ErrorValue.create(FLOAT_LITERAL_OUT_OF_RANGE.on(expression)); } } @Nullable - private CompileTimeConstant checkNativeType(String text, JetType expectedType, String title, JetType nativeType) { + private CompileTimeConstant checkNativeType( + JetType expectedType, + String title, + JetType nativeType, + JetConstantExpression expression + ) { if (!noExpectedTypeOrUnitOrError(expectedType) && !JetTypeChecker.INSTANCE.isSubtypeOf(nativeType, expectedType)) { - return new ErrorValue("A " + title + " literal " + text + " does not conform to the expected type " + expectedType); + + return ErrorValue.create(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, title, expectedType)); } return null; } @NotNull - public CompileTimeConstant getBooleanValue(@NotNull String text, @NotNull JetType expectedType) { - CompileTimeConstant error = checkNativeType(text, expectedType, "boolean", builtIns.getBooleanType()); + public CompileTimeConstant getBooleanValue( + @NotNull JetConstantExpression expression, @NotNull JetType expectedType + ) { + String text = expression.getText(); + CompileTimeConstant error = checkNativeType(expectedType, "boolean", builtIns.getBooleanType(), expression); if (error != null) { return error; } @@ -213,20 +248,23 @@ public class CompileTimeConstantResolver { } @NotNull - public CompileTimeConstant getCharValue(@NotNull String text, @NotNull JetType expectedType) { - CompileTimeConstant error = checkNativeType(text, expectedType, "character", builtIns.getCharType()); + public CompileTimeConstant getCharValue( + @NotNull JetConstantExpression expression, @NotNull JetType expectedType + ) { + String text = expression.getText(); + CompileTimeConstant error = checkNativeType(expectedType, "character", builtIns.getCharType(), expression); if (error != null) { return error; } // Strip the quotes if (text.length() < 2 || text.charAt(0) != '\'' || text.charAt(text.length() - 1) != '\'') { - return new ErrorValue("Incorrect character literal"); + return ErrorValue.create(INCORRECT_CHARACTER_LITERAL.on(expression)); } text = text.substring(1, text.length() - 1); // now there're no quotes if (text.length() == 0) { - return new ErrorValue("Empty character literal"); + return ErrorValue.create(EMPTY_CHARACTER_LITERAL.on(expression)); } if (text.charAt(0) != '\\') { @@ -234,13 +272,16 @@ public class CompileTimeConstantResolver { if (text.length() == 1) { return new CharValue(text.charAt(0)); } - return new ErrorValue("Too many characters in a character literal '" + text + "'"); + return ErrorValue.create(TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL.on(expression, expression)); } - return escapedStringToCharValue(text); + return escapedStringToCharValue(text, expression); } @NotNull - public static CompileTimeConstant escapedStringToCharValue(@NotNull String text) { + public static CompileTimeConstant escapedStringToCharValue( + @NotNull String text, + @NotNull JetElement expression + ) { assert text.length() > 0 && text.charAt(0) == '\\' : "Only escaped sequences must be passed to this routine: " + text; // Escape @@ -248,12 +289,12 @@ public class CompileTimeConstantResolver { switch (escape.length()) { case 0: // bare slash - return illegalEscape(text); + return illegalEscape(expression); case 1: // one-char escape Character escaped = translateEscape(escape.charAt(0)); if (escaped == null) { - return illegalEscape(text); + return illegalEscape(expression); } return new CharValue(escaped); case 5: @@ -268,11 +309,14 @@ public class CompileTimeConstantResolver { } break; } - return illegalEscape(text); + return illegalEscape(expression); } - private static ErrorValue illegalEscape(String text) { - return new ErrorValue("Illegal escape: " + text); + @NotNull + private static CompileTimeConstant illegalEscape( + @NotNull JetElement expression + ) { + return ErrorValue.create(ILLEGAL_ESCAPE.on(expression, expression)); } @Nullable @@ -299,11 +343,13 @@ public class CompileTimeConstantResolver { } @NotNull - public CompileTimeConstant getNullValue(@NotNull JetType expectedType) { + public CompileTimeConstant getNullValue( + @NotNull JetConstantExpression expression, @NotNull JetType expectedType + ) { if (noExpectedTypeOrUnitOrError(expectedType) || expectedType.isNullable()) { return NullValue.NULL; } - return new ErrorValue("Null can not be a value of a non-null type " + expectedType); + return ErrorValue.create(NULL_FOR_NONNULL_TYPE.on(expression, expectedType)); } private static boolean noExpectedTypeOrUnitOrError(JetType expectedType) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java index 48d5aad35f5..60f6817eb9a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/ErrorValue.java @@ -18,16 +18,13 @@ package org.jetbrains.jet.lang.resolve.constants; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.JetType; -public class ErrorValue implements CompileTimeConstant { - private final String message; - - public ErrorValue(@NotNull String message) { - this.message = message; - } +public abstract class ErrorValue implements CompileTimeConstant { @Override @Deprecated // Should not be called, for this is not a real value, but a indication of an error @@ -35,24 +32,62 @@ public class ErrorValue implements CompileTimeConstant { throw new UnsupportedOperationException(); } - @NotNull - @Override - public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) { - return ErrorUtils.createErrorType(message); - } - @Override public R accept(AnnotationArgumentVisitor visitor, D data) { return visitor.visitErrorValue(this, data); } - @NotNull - public String getMessage() { - return message; + public static ErrorValue create(@NotNull String message) { + return new ErrorValueWithMessage(message); } - @Override - public String toString() { - return message; + public static ErrorValue create(@NotNull Diagnostic diagnostic) { + return new ErrorValueWithDiagnostic(diagnostic); + } + + public static class ErrorValueWithMessage extends ErrorValue { + private final String message; + + public ErrorValueWithMessage(@NotNull String message) { + this.message = message; + } + + public String getMessage() { + return message; + } + + @NotNull + @Override + public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) { + return ErrorUtils.createErrorType(message); + } + + @Override + public String toString() { + return getMessage(); + } + } + + public static class ErrorValueWithDiagnostic extends ErrorValue { + private final Diagnostic diagnostic; + + public ErrorValueWithDiagnostic(@NotNull Diagnostic diagnostic) { + this.diagnostic = diagnostic; + } + + public Diagnostic getDiagnostic() { + return diagnostic; + } + + @NotNull + @Override + public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) { + throw new UnsupportedOperationException(); + } + + @Override + public String toString() { + return DefaultErrorMessages.RENDERER.render(diagnostic); + } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index 129320f3fee..60b46010b4f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorUtil; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; @@ -68,6 +69,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getStaticNestedClassesScope; import static org.jetbrains.jet.lang.resolve.calls.context.ContextDependency.DEPENDENT; import static org.jetbrains.jet.lang.resolve.calls.context.ContextDependency.INDEPENDENT; +import static org.jetbrains.jet.lang.resolve.constants.ErrorValue.ErrorValueWithDiagnostic; import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; import static org.jetbrains.jet.lang.types.TypeUtils.noExpectedType; @@ -145,10 +147,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { CompileTimeConstant value = compileTimeConstantResolver.getCompileTimeConstant(expression, context.expectedType); if (value instanceof ErrorValue) { - // 'checkType' for 'ContextDependency.DEPENDENT' will take place in 'completeInferenceForArgument' - if (context.contextDependency == INDEPENDENT) { - context.trace.report(ERROR_COMPILE_TIME_VALUE.on(expression, ((ErrorValue) value).getMessage())); - } + assert value instanceof ErrorValueWithDiagnostic; + //noinspection CastConflictsWithInstanceof + context.trace.report(((ErrorValueWithDiagnostic)value).getDiagnostic()); return JetTypeInfo.create(getDefaultType(elementType), context.dataFlowInfo); } context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, value); @@ -1106,9 +1107,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { public JetTypeInfo visitStringTemplateExpression(JetStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) { final ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT); final StringBuilder builder = new StringBuilder(); - final CompileTimeConstant[] value = new CompileTimeConstant[1]; - final DataFlowInfo[] dataFlowInfo = new DataFlowInfo[1]; - dataFlowInfo[0] = context.dataFlowInfo; + final boolean[] isCompileTimeValue = new boolean[] { true }; + final DataFlowInfo[] dataFlowInfo = new DataFlowInfo[] { context.dataFlowInfo }; for (JetStringTemplateEntry entry : expression.getEntries()) { entry.accept(new JetVisitorVoid() { @@ -1120,7 +1120,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetTypeInfo typeInfo = facade.getTypeInfo(entryExpression, context.replaceDataFlowInfo(dataFlowInfo[0])); dataFlowInfo[0] = typeInfo.getDataFlowInfo(); } - value[0] = CompileTimeConstantResolver.OUT_OF_RANGE; + isCompileTimeValue[0] = false; } @Override @@ -1130,12 +1130,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public void visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry) { - String text = entry.getText(); - - CompileTimeConstant character = CompileTimeConstantResolver.escapedStringToCharValue(text); + CompileTimeConstant character = CompileTimeConstantResolver.escapedStringToCharValue(entry.getText(), entry); if (character instanceof ErrorValue) { - context.trace.report(ILLEGAL_ESCAPE_SEQUENCE.on(entry)); - value[0] = CompileTimeConstantResolver.OUT_OF_RANGE; + assert character instanceof ErrorValueWithDiagnostic; + //noinspection CastConflictsWithInstanceof + context.trace.report(((ErrorValueWithDiagnostic) character).getDiagnostic()); + isCompileTimeValue[0] = false; } else { builder.append(((CharValue) character).getValue()); @@ -1143,7 +1143,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } }); } - if (value[0] != CompileTimeConstantResolver.OUT_OF_RANGE) { + if (isCompileTimeValue[0]) { context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new StringValue(builder.toString())); } return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getStringType(), expression, contextWithExpectedType, dataFlowInfo[0]); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java index fe25141f194..549c293d573 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java @@ -20,13 +20,16 @@ import com.intellij.openapi.util.Ref; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.calls.context.ContextDependency; import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValue; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory; +import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeInfo; @@ -168,6 +171,15 @@ public class DataFlowUtils { return expressionType; } + if (expression instanceof JetConstantExpression) { + Diagnostic diagnostic = + new CompileTimeConstantResolver().checkConstantExpressionType((JetConstantExpression) expression, expectedType); + if (diagnostic != null) { + trace.report(diagnostic); + } + return expressionType; + } + DataFlowValue dataFlowValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(expression, expressionType, trace.getBindingContext()); for (JetType possibleType : dataFlowInfo.getPossibleTypes(dataFlowValue)) { if (JetTypeChecker.INSTANCE.isSubtypeOf(possibleType, expectedType)) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 201daeb3aa1..d09f8bd9f44 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -462,7 +462,7 @@ public class ExpressionTypingUtils { @Override public void report(@NotNull Diagnostic diagnostic) { AbstractDiagnosticFactory factory = diagnostic.getFactory(); - if ((factory == TYPE_MISMATCH || factory == ERROR_COMPILE_TIME_VALUE) + if ((factory == TYPE_MISMATCH || factory == CONSTANT_EXPECTED_TYPE_MISMATCH) && diagnostic.getPsiElement() == expressionToWatch) { mismatchFound[0] = true; } diff --git a/compiler/testData/diagnostics/tests/CharacterLiterals.kt b/compiler/testData/diagnostics/tests/CharacterLiterals.kt index 9942668c574..b99ca7098fa 100644 --- a/compiler/testData/diagnostics/tests/CharacterLiterals.kt +++ b/compiler/testData/diagnostics/tests/CharacterLiterals.kt @@ -1,13 +1,13 @@ fun test(c : Char) { - test('') + test('') test('a') - test('aa') - test('a) - test(' + test('aa') + test('a) + test(' test(0' test('\n') test('\\') - test('''') + test('''') test('\'') test('\"') } diff --git a/compiler/testData/diagnostics/tests/Constants.kt b/compiler/testData/diagnostics/tests/Constants.kt index f90e13b1dd8..0fcfb1ebf6d 100644 --- a/compiler/testData/diagnostics/tests/Constants.kt +++ b/compiler/testData/diagnostics/tests/Constants.kt @@ -25,20 +25,20 @@ fun test() { 1e5: Double 1e-5: Float - 1: Double - 1: Float + 1: Double + 1: Float 1 as Byte 1 as Int 0xff as Long - 1.1 as Int - 1.1: Int + 1.1 as Int + 1.1: Int - varargByte(0x77, 1, 3, 200, 0b111) - varargShort(0x777, 1, 2, 3, 200000, 0b111) - varargInt(0x77777777, 0x7777777777, 1, 2, 3, 2000000000, 0b111) + varargByte(0x77, 1, 3, 200, 0b111) + varargShort(0x777, 1, 2, 3, 200000, 0b111) + varargInt(0x77777777, 0x7777777777, 1, 2, 3, 2000000000, 0b111) varargLong(0x777777777777, 1, 2, 3, 200000, 0b111) - varargFloat(1, 1.0, -0.1, 1e4, 1e-4, -1e4) - varargDouble(1, 1.0, -0.1, 1e4, 1e-4, -1e4) + varargFloat(1, 1.0, -0.1, 1e4, 1e-4, -1e4) + varargDouble(1, 1.0, -0.1, 1e4, 1e-4, -1e4) } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt b/compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt index 0e1230675d2..6bde61ccbe3 100644 --- a/compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt +++ b/compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt @@ -2,11 +2,11 @@ // KT-451 Incorrect character literals cause assertion failures fun ff() { - val b = '' - val c = '23' - val d = 'a - val e = 'ab - val f = '\' + val b = '' + val c = '23' + val d = 'a + val e = 'ab + val f = '\' } fun test() { @@ -19,19 +19,19 @@ fun test() { '\'' '\\' '\$' - '\x' - '\123' - '\ra' - '\000' - '\000' + '\x' + '\123' + '\ra' + '\000' + '\000' '\u0000' '\u000a' '\u000A' - '\u' - '\u0' - '\u00' - '\u000' - '\u000z' - '\\u000' - '\' + '\u' + '\u0' + '\u00' + '\u000' + '\u000z' + '\\u000' + '\' } diff --git a/compiler/testData/diagnostics/tests/ResolveToJava.kt b/compiler/testData/diagnostics/tests/ResolveToJava.kt index 7132e3988a1..a127e96b41c 100644 --- a/compiler/testData/diagnostics/tests/ResolveToJava.kt +++ b/compiler/testData/diagnostics/tests/ResolveToJava.kt @@ -24,7 +24,7 @@ fun test(l : java.util Collections.emptyList() Collections.singleton(1) : Set? - Collections.singleton(1.0) + Collections.singleton(1.0) List diff --git a/compiler/testData/diagnostics/tests/StringTemplates.kt b/compiler/testData/diagnostics/tests/StringTemplates.kt index 15bb94259ec..b9471dba648 100644 --- a/compiler/testData/diagnostics/tests/StringTemplates.kt +++ b/compiler/testData/diagnostics/tests/StringTemplates.kt @@ -11,12 +11,12 @@ fun demo() { "$" "$.$.asdf$\t" "asd\$" - "asd$a\x" + "asd$a\x" "asd$a$asd$ $xxx" "fosdfasdo${1 + bar + 100}}sdsdfgdsfsdf" "foo${bar + map {foo}}sdfsdf" "foo${bar + map { "foo" }}sdfsdf" "foo${bar + map { "foo$sdf${ buzz{}}" }}sdfsdf" - "a\u \u0 \u00 \u000 \u0000 \u0AaA \u0AAz.length( ) + \u0022b" + "a\u \u0 \u00 \u000 \u0000 \u0AaA \u0AAz.length( ) + \u0022b" } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/Varargs.kt b/compiler/testData/diagnostics/tests/Varargs.kt index bbc7b0d12c7..dff85f3bfe1 100644 --- a/compiler/testData/diagnostics/tests/Varargs.kt +++ b/compiler/testData/diagnostics/tests/Varargs.kt @@ -10,7 +10,7 @@ fun test() { v1() v1({}) v1({}, {}) - v1({}, 1, {}) + v1({}, 1, {}) v1({}, {}, {it}) v1({}) {} v1 {} diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt index 44c0419f47d..a5be87e48b3 100644 --- a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt +++ b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt @@ -12,17 +12,17 @@ fun test() { bar { } - foo("", 1, xx) + foo("", 1, xx) foo(r = xx, i = "", s = "") - foo(i = 1, i = 1, s = 11) + foo(i = 1, i = 1, s = 11) - foo("", s = 2) + foo("", s = 2) - foo(i = "", s = 2, 33) + foo(i = "", s = 2, 33) - foo("", 1) {} + foo("", 1) {} - foo("", 1) {} {} + foo("", 1) {} {} } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt index c815e3829ce..3fa89cc70e7 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt @@ -6,7 +6,7 @@ fun bar(a: T, b: Map) = b.get(a) fun test(a: Int) { foo(a, null) - bar(a, null) + bar(a, null) } fun test1(a: Int) { foo(a, throw Exception()) diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt index e40bc8873a3..f1b283d7ad0 100644 --- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt +++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt @@ -18,6 +18,6 @@ public class Y extends X { fun main() { Y().fooN() : Any - Y().barN(null); + Y().barN(null); } diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt index f44ffeaf690..28e2f9da261 100644 --- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt +++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt @@ -18,6 +18,6 @@ public class Y extends X { fun main() { Y().fooN() : Any - Y().barN(null); + Y().barN(null); } diff --git a/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt b/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt index f2a50a73bd7..bc1489c8f0b 100644 --- a/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt +++ b/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt @@ -5,12 +5,12 @@ fun foo(i: Int) = i fun bar(l: Long) = l fun main(args: Array) { - val i = 111111111111111777777777777777 + val i = 111111111111111777777777777777 //todo add diagnostic text messages //report only 'The value is out of range' //not 'An integer literal does not conform to the expected type Int/Long' - val l: Long = 1111111111111117777777777777777 - foo(11111111111111177777777777777) - bar(11111111111111177777777777777) + val l: Long = 1111111111111117777777777777777 + foo(11111111111111177777777777777) + bar(11111111111111177777777777777) } diff --git a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt index f85cb294f51..f492aad3524 100644 --- a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt +++ b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt @@ -26,9 +26,9 @@ fun test() { val g: Byte = either(1, 300) - other(11) + other(11) - otherGeneric(1) + otherGeneric(1) val r = either(1, "") r: Int diff --git a/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt b/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt index ad77063b27d..41950e5a44d 100644 --- a/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt +++ b/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt @@ -8,9 +8,9 @@ fun main(args : Array) { val h : String = v--; val h1 : String = --v; val i : String = !true; - val j : String = @foo true; - val j1 : String = @ true; - val j2 : String = @@ true; + val j : String = @foo true; + val j1 : String = @ true; + val j2 : String = @@ true; val k : String = -1; val l : String = +1; } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/regressions/kt411.kt b/compiler/testData/diagnostics/tests/regressions/kt411.kt index 7c0fd28b775..80d6d015f25 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt411.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt411.kt @@ -35,7 +35,7 @@ fun t3() : String { return@t3 "1" } else { - return 2 + return 2 } return@ 0 } diff --git a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java index dcf290972a9..9a021040250 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java @@ -189,7 +189,7 @@ public class CheckerTestUtilTest extends JetLiteFixture { private final List diagnostics = Lists.newArrayList( new DiagnosticData(0, 0, "UNUSED_PARAMETER", 8, 9), - new DiagnosticData(1, 1, "TYPE_MISMATCH", 56, 57), + new DiagnosticData(1, 1, "CONSTANT_EXPECTED_TYPE_MISMATCH", 56, 57), new DiagnosticData(2, 2, "UNUSED_VARIABLE", 67, 68), new DiagnosticData(3, 3, "TYPE_MISMATCH", 98, 99), new DiagnosticData(4, 4, "NONE_APPLICABLE", 120, 121), diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java index 6a90b595ede..192ca24507b 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java @@ -172,7 +172,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer @Override public void visit(String name, Object value) { CompileTimeConstant argument = JavaAnnotationArgumentResolver.resolveCompileTimeConstantValue(value, null); - setArgumentValueByName(name, argument != null ? argument : new ErrorValue("Unsupported annotation argument: " + name)); + setArgumentValueByName(name, argument != null ? argument : ErrorValue.create("Unsupported annotation argument: " + name)); } @Override @@ -196,7 +196,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer } } } - return new ErrorValue("Unresolved enum entry: " + enumFqName + "." + name); + return ErrorValue.create("Unresolved enum entry: " + enumFqName + "." + name); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java index 1d3da3cc362..cd38a64effe 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java @@ -164,7 +164,7 @@ public class JetPsiChecker implements Annotator { return; } - if (diagnostic.getFactory() == Errors.ILLEGAL_ESCAPE_SEQUENCE) { + if (diagnostic.getFactory() == Errors.ILLEGAL_ESCAPE) { for (TextRange textRange : diagnostic.getTextRanges()) { Annotation annotation = holder.createErrorAnnotation(textRange, getDefaultMessage(diagnostic)); annotation.setTooltip(getMessage(diagnostic)); diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterObjectInsideBody.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterObjectInsideBody.kt index ca18a2f71ec..1b56dabc276 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/afterObjectInsideBody.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterObjectInsideBody.kt @@ -1,5 +1,5 @@ // "Change 'prop' type to 'Int'" "true" -// ERROR: Null can not be a value of a non-null type Int +// ERROR: Null can not be a value of a non-null type jet.Int trait Test { val prop : T } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeObjectInsideBody.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeObjectInsideBody.kt index 98530b8ef50..87c818e2cd7 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeObjectInsideBody.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeObjectInsideBody.kt @@ -1,5 +1,5 @@ // "Change 'prop' type to 'Int'" "true" -// ERROR: Null can not be a value of a non-null type Int +// ERROR: Null can not be a value of a non-null type jet.Int trait Test { val prop : T } diff --git a/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch4.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch4.kt index a463ad6739e..ded1a62692a 100644 --- a/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch4.kt +++ b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch4.kt @@ -1,5 +1,5 @@ // "Change 'A.component2' function return type to 'Unit'" "true" -// ERROR: Type mismatch.
Required:jet.Unit
Found:jet.Int
+// ERROR: An integer literal does not conform to the expected type jet.Unit abstract class A { abstract fun component1(): Int fun component2(): Unit = 42 diff --git a/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt index 984fdd18142..24f6035667f 100644 --- a/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt +++ b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt @@ -1,5 +1,5 @@ // "Change 'A.component2' function return type to 'Unit'" "true" -// ERROR: Type mismatch.
Required:jet.Unit
Found:jet.Int
+// ERROR: An integer literal does not conform to the expected type jet.Unit abstract class A { abstract fun component1(): Int fun component2() = 42