Tmp
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
index b0c8e67..a45deaf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
@@ -52,9 +52,14 @@
private val classifierUsageCheckers: Iterable<ClassifierUsageChecker>
) {
fun analyzeDeclarations(
- topDownAnalysisMode: TopDownAnalysisMode,
- declarations: Collection<PsiElement>,
- outerDataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY
+ topDownAnalysisMode: TopDownAnalysisMode,
+ declarations: Collection<PsiElement>,
+ /**
+ * DFA
+ *
+ * This parameter is actually used in LocalClassifierAnalyzer
+ */
+ outerDataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY
): TopDownAnalysisContext {
val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider)
@@ -198,6 +203,15 @@
declaration.accept(visitor)
}
+ /**
+ * DFA
+ *
+ * Here we need DFI because we may have to resolve function body
+ * And if it is local function, then DFI matters
+ * And it *can* be local function, because LocalClassifierAnalyzer re-uses LazyTopDownAnalyzer
+ *
+ * Same for properties ofc
+ */
createFunctionDescriptors(c, functions)
createPropertyDescriptors(c, topLevelFqNames, properties)
@@ -219,6 +233,9 @@
overloadResolver.checkOverloads(c)
+ /**
+ * DFA
+ */
bodyResolver.resolveBodies(c)
resolveImportsInAllFiles(c)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
index b8aa75f..18a1b74 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
@@ -370,28 +370,41 @@
if (type == null || (type.isError && !type.isFunctionPlaceholder)) {
matchStatus = ArgumentMatchStatus.ARGUMENT_HAS_NO_TYPE
} else if (!noExpectedType(expectedType)) {
+ // argument has expected type
if (!ArgumentTypeResolver.isSubtypeOfForArgumentType(type, expectedType)) {
+ // and we have raw type mismatch. But wait, maybe we can get a smartcast!
val smartCast = smartCastValueArgumentTypeIfPossible(expression, newContext.expectedType, type, newContext)
if (smartCast == null) {
+ // No smartcast too :(
+ // It's already mismatch for sure, but let's check if we're passing nullable argument to non-nullable
+ // parameter to provide better diagnostic
resultStatus = tryNotNullableArgument(type, expectedType) ?: OTHER_ERROR
matchStatus = ArgumentMatchStatus.TYPE_MISMATCH
} else {
+ // Nice, we got smartcast, lets use it
resultingType = smartCast
}
} else if (ErrorUtils.containsUninferredParameter(expectedType)) {
+ // Nice, type of argument is subtype of expected type
+ // However, ArgumentTypeResolver.isSubtypeOfForArgumentType could return true if some types were
+ // not inferred. Let's check this and if there are some, use appropriate match status
matchStatus = ArgumentMatchStatus.MATCH_MODULO_UNINFERRED_TYPES
}
val spreadElement = argument.getSpreadElement()
if (spreadElement != null && !type.isFlexible() && type.isMarkedNullable) {
+ // Oh shi~, we're using spread on the nullable argument. Usually this is forbidden,
+ // but what if we have a smartcast around...
val dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, type, context)
val smartCastResult = SmartCastManager.checkAndRecordPossibleCast(
dataFlowValue, expectedType, expression, context,
call = null, recordExpressionType = false
)
if (smartCastResult == null || !smartCastResult.isCorrect) {
+ // Nope, we don't, so report error
context.trace.report(Errors.SPREAD_OF_NULLABLE.on(spreadElement))
}
+ // Otherwise, we do have suitable smartcast, so everything is OK
}
}
argumentTypes.add(resultingType)
@@ -511,8 +524,13 @@
val safeAccess = isExplicitReceiver && !implicitInvokeCheck && call.isSemanticallyEquivalentToSafeCall
val expectedReceiverParameterType = if (safeAccess) TypeUtils.makeNullable(receiverParameter.type) else receiverParameter.type
+ // Inside getSmartCastReceiverResult:
+ // 1. Create DFV from receiverArgument
+ // 2. Pull DFI from context
+ // 3. Ask DFI about .getCollectedTypes()
val smartCastSubtypingResult = smartCastManager.getSmartCastReceiverResult(receiverArgument, expectedReceiverParameterType, this)
if (smartCastSubtypingResult == null) {
+ // Ok, we can't smartcast, give up
tracing.wrongReceiverType(
trace, receiverParameter, receiverArgument,
this.replaceCallPosition(CallPosition.ExtensionReceiverPosition(candidateCall))
@@ -520,9 +538,12 @@
return OTHER_ERROR
}
+ // Here we have smartcast: either to type or to right nullability
+
val notNullReceiverExpected = smartCastSubtypingResult != SmartCastManager.ReceiverSmartCastResult.OK
val smartCastNeeded =
- notNullReceiverExpected || !isCandidateVisibleOrExtensionReceiver(receiverArgument, null, isDispatchReceiver)
+ // TODO: Ask how the extension receiver is related here
+ notNullReceiverExpected || !isCandidateVisibleOrExtensionReceiver(receiverArgument, null, isDispatchReceiver)
var reportUnsafeCall = false
var nullableImplicitInvokeReceiver = false
@@ -539,19 +560,26 @@
}
}
+ // Again traverse all DataFlowInfo
val dataFlowValue = DataFlowValueFactory.createDataFlowValue(receiverArgument, this)
val nullability = dataFlowInfo.getStableNullability(dataFlowValue)
+
val expression = (receiverArgument as? ExpressionReceiver)?.expression
- if (nullability.canBeNull() && !nullability.canBeNonNull()) {
+ if (nullability.canBeNull() && !nullability.canBeNonNull()) { // I.e. receiver is definitely null
if (!TypeUtils.isNullableType(expectedReceiverParameterType)) {
reportUnsafeCall = true
}
+
+ // This 'if' can be false for 'Nothing?' (i.e. for 'null' constant)
if (dataFlowValue.immanentNullability.canBeNonNull()) {
expression?.let { trace.record(BindingContext.SMARTCAST_NULL, it) }
}
} else if (!nullableImplicitInvokeReceiver && smartCastNeeded) {
+ // !nullability.canBeNull() || nullability.canBeNotNull() <=> canBeNotNull
// Look if smart cast has some useful nullability info
+ // Why the hell we go and ask for smartcasts second time? We've already asked above
+ // Reminder: dataFlowValue was manually created from receiverArgument
val smartCastResult = SmartCastManager.checkAndRecordPossibleCast(
dataFlowValue, expectedReceiverParameterType,
{ possibleSmartCast -> isCandidateVisibleOrExtensionReceiver(receiverArgument, possibleSmartCast, isDispatchReceiver) },
@@ -559,10 +587,13 @@
)
if (smartCastResult == null) {
+ // Sigh, no smartcast
if (notNullReceiverExpected) {
+ // But dude, we wanted not null! This is unsafe, bruh
reportUnsafeCall = true
}
} else {
+ // Ok we have some smartcast
if (isDispatchReceiver) {
candidateCall.setSmartCastDispatchReceiverType(smartCastResult.resultType)
} else {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.kt
index 22a32a1..385e788 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowValueFactory.kt
@@ -70,6 +70,34 @@
}
@JvmStatic
+ /*
+ 1. [Special case] 'null', 'Nothing?': special DFV
+ 2. [Special case] error-type: special DFV
+ 3. [Special case] '!!': force non-null DFV to prevent issues with generics
+ 4. Block, if, when, elvis: stable DFV for complex expression
+ 5. Qualified expression:
+ - selector info, when receiver is package or class
+ - NO, when receiver is NO
+ - QualifiedInfo otherwise. Stability = min(stability of receiver, stability of selector)
+ 6. 'is', 'as': NO
+ 7. 'as?': SafeCastInfo. stability <=> stability of subject
+ 8. '++', '--': PostfixInfo. stability <=> stability of argument
+ 9. 'this': Receiver(target)
+ 10. Property.
+ Check if this property is either: 'var', has open or custom getter, declared in other module.
+ If so, then it is unstable.
+ Otherwise it is stable.
+ 11. Local variable/function parameter.
+ - 'val': stable value
+ - 'var': generally, unstable, but can be relaxed for some cases
+ - if no one writes in this 'var', then it is considered stable
+ - if inside closure: generally, unstable, but can be relaxed for some cases:
+ - if all writers are reliably "before" closured access, then considered stable
+ - if not inside closure, but has closure writers: generally, unstable, but can be relaxed for some cases:
+ - if all closure writers are provably "after" access, then considered stable
+ NB. Also consider implicit receivers, and create QualifiedInfo, if it is present
+
+ */
fun createDataFlowValue(
expression: KtExpression,
type: KotlinType,
@@ -92,6 +120,8 @@
//
// But there are some problem with types built on type parameters, e.g.
// fun <T : Any?> foo(x: T) = x!!.hashCode() // there no way in type system to denote that `x!!` is not nullable
+ //
+ // This is closely connected with 'immanentlyNotNull' checks in the second part of 'SmartCastManager.checkAndRecordPossibleCast()'
return DataFlowValue(
ExpressionIdentifierInfo(expression),
type,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.kt
index 42988fc..926a4e5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.kt
@@ -102,8 +102,7 @@
}
val identifierInfo = value.identifierInfo
- if (affectReceiver && !nullability.canBeNull() &&
- languageVersionSettings.supportsFeature(LanguageFeature.SafeCallBoundSmartCasts)) {
+ if (affectReceiver && !nullability.canBeNull() && languageVersionSettings.supportsFeature(LanguageFeature.SafeCallBoundSmartCasts)) {
when (identifierInfo) {
is IdentifierInfo.Qualified -> {
val receiverType = identifierInfo.receiverType
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.kt
index 2419a68..b4b2913 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/SmartCastManager.kt
@@ -82,18 +82,27 @@
return dataFlowInfo.getCollectedTypes(dataFlowValue, languageVersionSettings)
}
+ // Checks if `receiverArgument` can be cast to `receiverParameterType` with smartcasts taken into consideration
fun getSmartCastReceiverResult(
receiverArgument: ReceiverValue,
receiverParameterType: KotlinType,
context: ResolutionContext<*>
): ReceiverSmartCastResult? {
+ // Ok, let's just check if some cast is known with exact types
getSmartCastReceiverResultWithGivenNullability(receiverArgument, receiverParameterType, context)?.let {
+ // We have some cast with exact type
+ // Noe that it also returns for plain subtypes
return it
}
+ // No luck here, but maybe we can find suitable cast for nullable reciever?
val nullableParameterType = TypeUtils.makeNullable(receiverParameterType)
+
return when {
+ // Still no luck, return 'null'
getSmartCastReceiverResultWithGivenNullability(receiverArgument, nullableParameterType, context) == null -> null
+
+ // Found cast, but note that we've expanded nullability, so no matters what we've found, it's still "NOT_NULL_EXPECTED"
else -> ReceiverSmartCastResult.SMARTCAST_NEEDED_OR_NOT_NULL_EXPECTED
}
}
@@ -115,6 +124,7 @@
enum class ReceiverSmartCastResult {
OK,
+ // Fun fact -- it is used only in SmartCastManager
SMARTCAST_NEEDED_OR_NOT_NULL_EXPECTED
}
@@ -130,14 +140,21 @@
) {
if (KotlinBuiltIns.isNullableNothing(type)) return
if (dataFlowValue.isStable) {
+ // Smartcast is possible, lets try to do this!
+
val oldSmartCasts = trace[SMARTCAST, expression]
val newSmartCast = SingleSmartCast(call, type)
if (oldSmartCasts != null) {
+ // There already was some smartcast on that expression
+
+ // Let's check if this SMARTCAST slice (for the same expression!) already contains cast for this particular 'call'
val oldType = oldSmartCasts.type(call)
if (oldType != null && oldType != type) {
+ // Oops, this slice already contains smartcast for this particular 'call'
throw AssertionError("Rewriting key $call for smart cast on ${expression.text}")
}
}
+ // Ok, either there was no SMARTCAST slice at all for this 'expression', or it didn't contain a cast for this particular call
trace.record(SMARTCAST, expression, oldSmartCasts?.let { it + newSmartCast } ?: newSmartCast)
if (recordExpressionType) {
//TODO
@@ -145,6 +162,7 @@
trace.recordType(expression, type)
}
} else {
+ // Unstable data
trace.report(SMARTCAST_IMPOSSIBLE.on(expression, type, expression.text, dataFlowValue.kind.description))
}
}
@@ -160,6 +178,16 @@
return checkAndRecordPossibleCast(dataFlowValue, expectedType, null, expression, c, call, recordExpressionType)
}
+ /*
+ Semantics of this method:
+ 1. Take 'dataFlowValue'
+ 2. Pull 'dataFlowInfo' from 'c' and get all types for that 'dataFlowValue'
+ 3. If some of that types matches 'expectedType' and 'additionalPredicate' (if any), then record smartcast/error (i.e. diagnostic) with stability taken into consideration
+ (can also involve some additional hoops for implicit receiver)
+
+ IF NO TYPES WERE MATCHED ON PREVIOUS STEP, THEN:
+ 4.
+ */
fun checkAndRecordPossibleCast(
dataFlowValue: DataFlowValue,
expectedType: KotlinType,
@@ -171,14 +199,24 @@
): SmartCastResult? {
val calleeExpression = call?.calleeExpression
for (possibleType in c.dataFlowInfo.getCollectedTypes(dataFlowValue, c.languageVersionSettings)) {
+ // Check another type from smartcast
if (ArgumentTypeResolver.isSubtypeOfForArgumentType(possibleType, expectedType) &&
(additionalPredicate == null || additionalPredicate(possibleType))
) {
+ // This type suits us!
if (expression != null) {
+ // records cast if DFV is stable (with rewrite checks) OR records SMARTCAST_IMPOSSIBLE if DFV is unstable
recordCastOrError(expression, possibleType, c.trace, dataFlowValue, call, recordExpressionType)
} else if (calleeExpression != null && dataFlowValue.isStable) {
+ // This is the case when we have implicit receiver (e.g. in cases like 'with(a) { if (this is String) ... }'
+ // or in the body of extension function)
+ //
+ // Here we have to invent additional diagnostic on call itself
val receiver = (dataFlowValue.identifierInfo as? IdentifierInfo.Receiver)?.value
if (receiver is ImplicitReceiver) {
+ // This is the case #2
+
+ // dat logic duplication tho (see above)
val oldSmartCasts = c.trace[IMPLICIT_RECEIVER_SMARTCAST, calleeExpression]
val newSmartCasts = ImplicitSmartCasts(receiver, possibleType)
if (oldSmartCasts != null) {
@@ -192,14 +230,17 @@
}
c.trace.record(IMPLICIT_RECEIVER_SMARTCAST, calleeExpression,
oldSmartCasts?.let { it + newSmartCasts } ?: newSmartCasts)
-
}
}
+
+ // ...but who the fuck is going to report this smartcast? :(
return SmartCastResult(possibleType, dataFlowValue.isStable)
}
}
if (!c.dataFlowInfo.getCollectedNullability(dataFlowValue).canBeNull() && !expectedType.isMarkedNullable) {
+ // Ok, this value can't be null, and we expect not-null
+
// Handling cases like:
// fun bar(x: Any) {}
// fun <T : Any?> foo(x: T) {
@@ -208,23 +249,45 @@
// }
// }
//
- // It doesn't handled by lower code with getPossibleTypes because smart cast of T after `x != null` is still has same type T.
+ // It doesn't handled by upper code with getCollectedTypes because smart cast of T after `x != null` is still has same type T.
// But at the same time we're sure that `x` can't be null and just check for such cases manually
// E.g. in case x!! when x has type of T where T is type parameter with nullable upper bounds
// x!! is immanently not null (see DataFlowValueFactory.createDataFlowValue for expression)
+
+
+ // Segment below is much easier to understand if considered without 'immanentlyNotNull' flag
+
+ // Essentially, this is fast path for cases when 'dataFlowValue.type' can be casted to 'expected type'
+ // with the help of smartcasts.
val immanentlyNotNull = !dataFlowValue.immanentNullability.canBeNull()
val nullableExpectedType = TypeUtils.makeNullable(expectedType)
+ // Let's check if types are suitable modulo nullability smartcast
if (ArgumentTypeResolver.isSubtypeOfForArgumentType(dataFlowValue.type, nullableExpectedType) &&
(additionalPredicate == null || additionalPredicate(dataFlowValue.type))
) {
+ // Ok, dataFlowValue.type <: expectedType?
+ // AND
+ // we know what dataFlowValue can be casted to not-null, and we expect not-null
+ // =>
+ // let's record smartcast!
if (!immanentlyNotNull && expression != null) {
+ // Let's record smartcast!
recordCastOrError(expression, dataFlowValue.type, c.trace, dataFlowValue, call, recordExpressionType)
}
return SmartCastResult(dataFlowValue.type, immanentlyNotNull || dataFlowValue.isStable)
}
+ // Now, why do we even have that 'immanentlyNotNull' flag?
+ // Because it indicates that we're doing '!!'-assertion on generic type with nullable upper bound, which should be
+ // handled separately if it is in call chain (i.e. in cases like 'x!!.foo) because we have no other place to
+ // handle this case (compare that with cases like 'x!!; x.length' - here first statement provides DFI that x != null,
+ // and we already see it in the second statement)
+
+
+ // Ok, so we can't transform 'dataFlowValue' to 'expectedType' via nullability smartcast
+ // We say here: let's try again, but we will try to find cast to the nullable expected type
return checkAndRecordPossibleCast(dataFlowValue, nullableExpectedType, expression, c, call, recordExpressionType)
}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
index f26cd4b..e978ff5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
@@ -173,6 +173,9 @@
return components.dataFlowAnalyzer.checkType(typeInfo, expression, context); // TODO : Extensions to this
}
+ /*
+ Veeeeeery suspicious
+ */
@Override
public KotlinTypeInfo visitParenthesizedExpression(@NotNull KtParenthesizedExpression expression, ExpressionTypingContext context) {
KtExpression innerExpression = expression.getExpression();
@@ -190,6 +193,10 @@
return result;
}
+
+ /*
+ Returns the same data-flow info, as in the context
+ */
@Override
public KotlinTypeInfo visitConstantExpression(@NotNull KtConstantExpression expression, ExpressionTypingContext context) {
IElementType elementType = expression.getNode().getElementType();
@@ -293,6 +300,9 @@
}
}
+ /*
+ Returns the same info + maybe enhances it with "as"-cast info
+ */
@Override
public KotlinTypeInfo visitBinaryWithTypeRHSExpression(
@NotNull KtBinaryExpressionWithTypeRHS expression,
@@ -658,6 +668,9 @@
return components.doubleColonExpressionResolver.visitClassLiteralExpression(expression, c);
}
+ /*
+ Seems like no extra data-flow hoops, but have to re-check
+ */
@Override
public KotlinTypeInfo visitCallableReferenceExpression(@NotNull KtCallableReferenceExpression expression, ExpressionTypingContext c) {
return components.doubleColonExpressionResolver.visitCallableReferenceExpression(expression, c);
@@ -819,6 +832,9 @@
contextWithExpectedType.replaceDataFlowInfo(typeInfo.getDataFlowInfo()));
}
+ /*
+ Practically no non-trivial data-flow manipulations except for casually forcing non-nullability of argument.
+ */
private KotlinTypeInfo visitExclExclExpression(@NotNull KtUnaryExpression expression, @NotNull ExpressionTypingContext context) {
KtExpression baseExpression = expression.getBaseExpression();
assert baseExpression != null;
@@ -847,6 +863,7 @@
assert baseTypeInfo != null : "Base expression was not processed: " + expression;
KotlinType baseType = baseTypeInfo.getType();
if (baseType == null) {
+ // Can get here in case of esoteric red code, like "java.lang.System!!"
return baseTypeInfo;
}
DataFlowInfo dataFlowInfo = baseTypeInfo.getDataFlowInfo();
@@ -1254,6 +1271,8 @@
KotlinTypeInfo leftTypeInfo = BindingContextUtils.getRecordedTypeInfo(left, context.trace.getBindingContext());
boolean isLeftFunctionLiteral = ArgumentTypeResolver.isFunctionLiteralArgument(left, context);
boolean isLeftCallableReference = ArgumentTypeResolver.isCallableReferenceArgument(left, context);
+
+ // Hoops with function literals and callable references
if (leftTypeInfo == null && (isLeftFunctionLiteral || isLeftCallableReference)) {
DiagnosticFactory0<PsiElement> diagnosticFactory =
isLeftFunctionLiteral ? USELESS_ELVIS_ON_LAMBDA_EXPRESSION : USELESS_ELVIS_ON_CALLABLE_REFERENCE;
@@ -1261,6 +1280,8 @@
return TypeInfoFactoryKt.noTypeInfo(context);
}
assert leftTypeInfo != null : "Left expression was not processed: " + expression;
+
+ // USELESS_ELVIS diagnostics
KotlinType leftType = leftTypeInfo.getType();
if (isKnownToBeNotNull(left, leftType, context)) {
context.trace.report(USELESS_ELVIS.on(expression, leftType));
@@ -1268,45 +1289,60 @@
else if (KtPsiUtil.isNullConstant(right) && leftType != null && !FlexibleTypesKt.isNullabilityFlexible(leftType)) {
context.trace.report(USELESS_ELVIS_RIGHT_IS_NULL.on(expression));
}
+
+ // Hoops with function literals and callable references
KotlinTypeInfo rightTypeInfo = BindingContextUtils.getRecordedTypeInfo(right, context.trace.getBindingContext());
if (rightTypeInfo == null && ArgumentTypeResolver.isFunctionLiteralOrCallableReference(right, context)) {
// the type is computed later in call completer according to the '?:' semantics as a function
return TypeInfoFactoryKt.noTypeInfo(context);
}
+
assert rightTypeInfo != null : "Right expression was not processed: " + expression;
- boolean loopBreakContinuePossible = leftTypeInfo.getJumpOutPossible() || rightTypeInfo.getJumpOutPossible();
KotlinType rightType = rightTypeInfo.getType();
+ // DataFlowShit starts here
+ boolean loopBreakContinuePossible = leftTypeInfo.getJumpOutPossible() || rightTypeInfo.getJumpOutPossible();
+
// Only left argument DFA is taken into account here: we cannot be sure that right argument is joined
// (we merge it with right DFA if right argument contains no jump outside)
- DataFlowInfo dataFlowInfo = resolvedCall.getDataFlowInfoForArguments().getInfo(call.getValueArguments().get(1));
+ DataFlowInfo resultDataFlowInfo = resolvedCall.getDataFlowInfoForArguments().getInfo(call.getValueArguments().get(1));
+
KotlinType type = resolvedCall.getResultingDescriptor().getReturnType();
if (type == null ||
rightType == null ||
- leftType == null && KotlinBuiltIns.isNothing(rightType)) return TypeInfoFactoryKt.noTypeInfo(dataFlowInfo);
+ leftType == null && KotlinBuiltIns.isNothing(rightType)
+ ) {
+ return TypeInfoFactoryKt.noTypeInfo(resultDataFlowInfo);
+ }
if (leftType != null) {
+ // This one is about logic "if right value is somehow breaks flow, then left is non-null"
DataFlowValue leftValue = createDataFlowValue(left, leftType, context);
DataFlowInfo rightDataFlowInfo = resolvedCall.getDataFlowInfoForArguments().getResultInfo();
boolean jumpInRight = KotlinBuiltIns.isNothing(rightType);
DataFlowValue nullValue = DataFlowValue.nullValue(components.builtIns);
+
// left argument is considered not-null if it's not-null also in right part or if we have jump in right part
if (jumpInRight || !rightDataFlowInfo.getStableNullability(leftValue).canBeNull()) {
- dataFlowInfo = dataFlowInfo.disequate(leftValue, nullValue, components.languageVersionSettings);
+ resultDataFlowInfo = resultDataFlowInfo.disequate(leftValue, nullValue, components.languageVersionSettings);
+
+ // Here we cover cases like "(x as? Foo) ?: return". Since 1.2, we have SafeCastCheckBoundSmartCasts language feature,
+ // which cover such cases more generally
if (left instanceof KtBinaryExpressionWithTypeRHS) {
- dataFlowInfo = establishSubtypingForTypeRHS((KtBinaryExpressionWithTypeRHS) left, dataFlowInfo, context,
+ resultDataFlowInfo = establishSubtypingForTypeRHS((KtBinaryExpressionWithTypeRHS) left, resultDataFlowInfo, context,
components.languageVersionSettings);
}
}
+
DataFlowValue resultValue = DataFlowValueFactory.createDataFlowValue(expression, type, context);
- dataFlowInfo =
- dataFlowInfo.assign(resultValue, leftValue, components.languageVersionSettings)
+ resultDataFlowInfo =
+ resultDataFlowInfo.assign(resultValue, leftValue, components.languageVersionSettings)
.disequate(resultValue, nullValue, components.languageVersionSettings);
if (!jumpInRight) {
DataFlowValue rightValue = DataFlowValueFactory.createDataFlowValue(right, rightType, context);
rightDataFlowInfo = rightDataFlowInfo.assign(resultValue, rightValue, components.languageVersionSettings);
- dataFlowInfo = dataFlowInfo.or(rightDataFlowInfo);
+ resultDataFlowInfo = resultDataFlowInfo.or(rightDataFlowInfo);
}
}
@@ -1316,16 +1352,24 @@
type = TypeUtils.makeNotNullable(type);
}
if (context.contextDependency == DEPENDENT) {
- return TypeInfoFactoryKt.createTypeInfo(type, dataFlowInfo);
+ return TypeInfoFactoryKt.createTypeInfo(type, resultDataFlowInfo);
}
// If break or continue was possible, take condition check info as the jump info
+ // components.dataFlowAnalyzer.createCheckedTypeInfo(type, contextWithExpectedType, expression);
+ // <=> checkType(TypeInfoFactoryKt.createTypeInfo(type, context), expression, context)
+ // <=> TypeInfoFactoryKt.createTypeInfo(type, context).replaceType(checkType(type), expression, context)
+ // <=> TypeInfoFactoryKT.createTypeInfo(checkType(type), expression, context
+
return TypeInfoFactoryKt.createTypeInfo(components.dataFlowAnalyzer.checkType(type, expression, contextWithExpectedType),
- dataFlowInfo,
+ resultDataFlowInfo,
loopBreakContinuePossible,
context.dataFlowInfo);
}
+ /*
+ Obsolete, see comment at use-site
+ */
@NotNull
private static DataFlowInfo establishSubtypingForTypeRHS(
@NotNull KtBinaryExpressionWithTypeRHS left,
@@ -1348,10 +1392,24 @@
return dataFlowInfo;
}
+ /*
+ Nothing too special, just regular linear data-flow juggling, but note that order is different:
+ 1. Resolve *right* expression in basic context, get data flow info after right ("dataFlowInfo")
+
+ 2. Resolve *whole* call in the context of right-expression ("contextWithDataFlow")
+ Note that it will compute data-flow info for left-expression too, as part of resolving arguments of desugared call
+
+ 3. Get data flow info for *left* expression in the "contextWithDataFlow" (will just take already computed data-flow info from trace), "flowForLeft"
+
+ 4. Return 'and'-merged flow for left and flow for right (orly??) <=> dataFlowInfo && flowForLeft
+ Note that implementation doesn't create new TypeInfo and instead mutates 'rightTypeInfo', which is quite confusing tbh.
+ Also note that 'and'-merging flow for left and right is most probably not correct (similar to 'and'-merging in DataFlowInfoForArguments),
+ but luckily we don't have (yet) constructions with non-trivial enough flow to break this.
+ */
@NotNull
public KotlinTypeInfo checkInExpression(
@NotNull KtElement callElement,
- @NotNull KtSimpleNameExpression operationSign,
+ @NotNull KtSimpleNameExpression operationSign, // either "in" or "!in"
@NotNull ValueArgument leftArgument,
@Nullable KtExpression right,
@NotNull ExpressionTypingContext context
@@ -1378,8 +1436,8 @@
ensureBooleanResult(operationSign, OperatorNameConventions.CONTAINS, containsType, context);
if (left != null) {
- dataFlowInfo = facade.getTypeInfo(left, contextWithDataFlow).getDataFlowInfo().and(dataFlowInfo);
- rightTypeInfo = rightTypeInfo.replaceDataFlowInfo(dataFlowInfo);
+ DataFlowInfo flowForLeft = facade.getTypeInfo(left, contextWithDataFlow).getDataFlowInfo();
+ rightTypeInfo = rightTypeInfo.replaceDataFlowInfo(flowForLeft);
}
if (resolutionResult.isSuccess()) {
@@ -1490,6 +1548,12 @@
return declarationInIllegalContext(property, context);
}
+ /*
+ Very trivial manipulations:
+ - resolve lhs in basic context
+ - resolve rhs in context with info from lhs
+ - use rhs resulting info (resolvedCall.dataFlowInfoForArguments.resultInfo) as result
+ */
@NotNull
private KotlinTypeInfo getTypeInfoForBinaryCall(
@NotNull Name name,
@@ -1676,6 +1740,13 @@
return resolveArrayAccessSpecialMethod(arrayAccessExpression, null, context, context.trace, true, false);
}
+ /*
+ 1. Take data flow for array call (e.g. for "foo()" in "foo()[bar(), baz(), bak()]", "arrayTypeInfo"
+ 2. If there are any indices, take data flow for all indices computation (as usual, this is resolved as call, and indices are arguments, so resulting info is
+ bound to the last argument)
+ 3. If there are rightHandSide (for 'set'-method), then take data flow for it instead (it's not obvious, but it *will* contain info about indices, because both
+ indices and RHS are analyzed during synthethic-call resolution as arguments, and dataFlow for them is already recorded)
+ */
@NotNull
private KotlinTypeInfo resolveArrayAccessSpecialMethod(
@NotNull KtArrayAccessExpression arrayAccessExpression,
@@ -1700,6 +1771,9 @@
Call call = isGet
? CallMaker.makeArrayGetCall(receiver, arrayAccessExpression, Call.CallType.ARRAY_GET_METHOD)
: CallMaker.makeArraySetCall(receiver, arrayAccessExpression, rightHandSide, Call.CallType.ARRAY_SET_METHOD);
+
+ // As a side effect, this call will record typeinfo for rightHandSide
+ // Quite logical, if you think about it, but totally not obvious from a first glance
OverloadResolutionResults<FunctionDescriptor> functionResults = components.callResolver.resolveCallWithGivenName(
context, call, arrayAccessExpression, isGet ? OperatorNameConventions.GET : OperatorNameConventions.SET);
@@ -1711,6 +1785,11 @@
}
if (!isGet) {
+ // Surprise-surprise: though that looks like we're saying here:
+ // "Take context info(which is empty atm), and resolve 'rightHandSide' in that context, and then *OVERWRITE* current info with it"
+ // And one could (rightfully) think that this is wrong, because it obviously won't contain data-flow information about indices
+ // But no!
+ // In face, getTypeInfo will take out cached type info, calculated by someone else, which apparently *does* contain info about indices
resultTypeInfo = facade.getTypeInfo(rightHandSide, context);
}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
index 0a9341a..850d601 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
@@ -251,6 +251,33 @@
return visitWhileExpression(expression, context, false);
}
+ /*
+ 0. Check if it is used as statement, exit with reporting, if so
+ 1. Launch PreliminaryLoopVisitor to clear DFI for all variables assigned in loop
+ 2. Extract type info from body:
+ - If body is present, then resolve its body in context with DFI = "(condition == true) && (condition finished)"
+ - Otherwise, use empty type info
+ 3. Infer outer info:
+ Step a. Initialize "result: DataFlowInfo" with context data flow info (remember, it has already all assigned variables cleared)
+ Step b. Update "result &= dfi(condition finished)".
+ Step c. If there is no jumpout in body, then update "result &= dfi(condition == true)"
+ Step d. If it is 'while(true)', then further update 'result &= jumpOutInfo' <=> 'result &= dfi(first break in loop body) - assignedVariablesInfo'
+
+ Possible higher-level logic:
+ 0. Check if it is used as statement, exit with reporting
+ 1. dataFlowResults = analyzer.analyzeWhileLoop(whileExpression, context)
+ - launches PreliminiaryLoopVisitor, clears DFI for all variables assigned in loop
+ - extracts "condition == true"
+ - extracts "condition finished"
+ - ? returns some lightweight view, maybe even lazy one
+ 2. contextForBody = dataFlowResults.getContextForBodyResultion()
+ - returns context with "(condition == true) && (condition finished)"
+ 3. Resolve body in contextForBody. This will return "dataFlowInfoForBlock"
+ 4. analyzer.feed(dataFlowInfoForBlock) // submit info about body into analyzer, analyzer will decide what should be done about it
+ 5. return analyzer.loopResultInfo
+
+ */
+
public KotlinTypeInfo visitWhileExpression(KtWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade);
@@ -344,6 +371,22 @@
return visitDoWhileExpression(expression, context, false);
}
+ /*
+ 0. Check if it is used as statement, returning with diagnostic if so
+ 1. Launch PreliminaryVisitor to clear all info about variables assigned in loop
+ 2. Extract body info:
+ - if body is present, then resolve it in current context (remember, it has already all asigned variables cleared)
+ - otherwise, no type info
+ 3. Resolve condition:
+ - use context DFI (*NOT* a body DFI!)
+ - use *BODY* scope (hello, nice "feature" of using val's, declared in do-while body, in condition)
+ 4. Infer outer info:
+ Step a.
+ - If no jumpouts in body, then we initialize "result" to "dfi(condition == true) && dfi(condition finished)"
+ - If there are jumpouts in body, then initialize "result" to context dfi (dfi at the enter of loop - all assigned variables)
+ Step b. Update "result" with "result &= jumpOutInfo" <=> "result &= dataFlowInfoAtFirstBreak - allAssignedVariables"
+
+ */
public KotlinTypeInfo visitDoWhileExpression(KtDoWhileExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade);
@@ -411,6 +454,17 @@
return visitForExpression(expression, context, false);
}
+ /*
+ 0. If used as statement, return with diagnostic
+ 1. Launch loopVisitor to clear all info for all assigned variables, producing context'
+ 2. Extract loopRangeInfo
+ - if loopRangeExpression is present, then resolve it in context'
+ - otherwise, use empty type info
+ 3. Extract body type info:
+ - if body is present, then resolve it in context of loopRangeInfo
+ - otherwise, use empty type info
+ 4. Use loopRangeInfo as outer info
+ */
public KotlinTypeInfo visitForExpression(KtForExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
if (!isStatement) return components.dataFlowAnalyzer.illegalStatementType(expression, contextWithExpectedType, facade);
@@ -503,6 +557,22 @@
return variableDescriptor;
}
+ /*
+ 0. Let context' = current contexxt with no context dependency
+ 1. Extract info from try-block in context'
+ 2. Infer info at the end of try-catch, "tryOutputContext":
+ Step a. initialize to context'.dataFlowInfo
+ Step b. If it is possible to fall-through at least one catch-clause (i.e. not every catch-clause ends with jumpout),
+ then launch PreliminaryVisitor and clear info for all assigned variables in 'try'
+ 3. If there is a finally clause, then resolve it in "tryOutputContext" context
+ 4. Infer info at the end of the whole try-expression (with all catches and finaly-clause, if any), "result":
+ Step a. Initialize "result" to "tryOutputContext", i.e. very conservative info (it is <= context info)
+ Step b. If finally is present, then we're sure that it is executed.
+ Update "result" to the finally's info
+ Step c. If finally is not present, but fall-through is impossible, then we're sure that try-block is executed.
+ Update "result" to the info at the end of the try-block, "tryResult".
+ 5. Return "result"
+ */
@Override
public KotlinTypeInfo visitTryExpression(@NotNull KtTryExpression expression, ExpressionTypingContext typingContext) {
ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT);
@@ -565,6 +635,7 @@
if (type != null) {
types.add(type);
}
+
if (types.isEmpty()) {
return result.clearType();
}
@@ -607,6 +678,10 @@
}
@Override
+ /*
+ No data-flow manipulations whatsoever, in the end it returns context.dataFlowInfo, though that's highly obscure and
+ non-obvious at the first glance
+ */
public KotlinTypeInfo visitReturnExpression(@NotNull KtReturnExpression expression, ExpressionTypingContext context) {
KtElement labelTargetElement = LabelResolver.INSTANCE.resolveControlLabel(expression, context);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
index ffe01d5..f501955 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java
@@ -122,6 +122,37 @@
return !typeHasOverriddenEquals(type, lookupElement);
}
+ /*
+ Visits PSI-tree which contains some boolean condition, and extracts
+ data flow info, given that it is known that this 'condition' is equal to 'conditionValue'.
+
+ 1. For 'is'-expression: just take recorded DFI from trace
+ Intricacies:
+ - check that it indeed brings us subtype infromation. Case chasing: "if operator isn't inverted
+ and 'conditionValue' == true, then record subtyping; if operator is inverted and 'conditionValue == false',
+ then record subtyping; otherwise do not record anything (we don't have a notion of "not-subtype-of" in compiler)
+
+ 2. For binary operator: do recursive calls on arguments and merge DFI
+ Intricacies:
+ - short-circuit logic
+ - choosing right operator for merging (case chasing: if operator is '&&' and 'conditionValue == true', then
+ merge with 'AND'; if operator is '||' and 'conditionValue == false', then merge with 'OR'; ...)
+
+ 3. For equals operator: equate 'left' and 'right'
+ Intricacies:
+ - Identity equals
+ - choosing right operator (equate vs. disequate + inversion in case of 'conditionValue == false')
+
+ 4. For elvis: lower
+ 'E ?: false' -> 'E == true',
+ 'E ?: true' -> 'E == false'
+ where "E" is some expression of nullable type
+
+ 5. For unary negation: recruse with inverted 'conditionValue'
+
+ 6. For everything else: just take recorded DFI from trace
+
+ */
@NotNull
public DataFlowInfo extractDataFlowInfoFromCondition(
@Nullable KtExpression condition,
@@ -270,6 +301,20 @@
}
@NotNull
+ /*
+ If expected type is not present, trivial, or not denotable -- then do not check anything.
+ Also omit trivial checks (if expression is already subtype of expected type)
+
+ Then:
+ - for constant expressions, check its type via CompileTimeConstantChecker in light mode
+ - for when expression, do nothing
+ - for all the rest, try to get smartcast, and return, if suitable is found.
+
+ Otherwise, there's type mismatch and we have to report it properly:
+ - Special case: type mismatch was because of type projections
+ - Special case: type mismatch was because of Scala-like function syntax
+ - Otherwise, just report generic "Expected X but got Y"
+ */
private KotlinType checkTypeInternal(
@NotNull KotlinType expressionType,
@NotNull KtExpression expression,
@@ -307,6 +352,12 @@
return expressionType;
}
+ /*
+ 1. Record expected type
+ - Needed for IDE, and ControlFlowAnalyzer
+ 2. Call into cehckTypeInternal
+ 3. Run additional type checkers
+ */
@Nullable
public KotlinType checkType(
@Nullable KotlinType expressionType,
@@ -405,6 +456,9 @@
}
@NotNull
+ /*
+ Returns the same dataflow, as in the passed context
+ */
public KotlinTypeInfo createCompileTimeConstantTypeInfo(
@NotNull CompileTimeConstant<?> value,
@NotNull KtExpression expression,
diff --git a/compiler/testData/diagnostics/tests/smartCasts/foobar.kt b/compiler/testData/diagnostics/tests/smartCasts/foobar.kt
new file mode 100644
index 0000000..6213d0a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/smartCasts/foobar.kt
@@ -0,0 +1,11 @@
+fun bar(x: Array<Int>?, y: Int?) {
+ if (y!! in x!!) {
+ y.inc()
+ x.size
+ } else {
+ y.inc()
+ x.size
+ }
+ y.inc()
+ x.size
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/foobar.txt b/compiler/testData/diagnostics/tests/smartCasts/foobar.txt
new file mode 100644
index 0000000..e0de512
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/smartCasts/foobar.txt
@@ -0,0 +1,11 @@
+package
+
+public fun </*0*/ T : Foo?> text(/*0*/ x: T): kotlin.Unit
+public fun kotlin.Int.bar(): kotlin.Int
+
+public interface Foo {
+ public abstract val length: kotlin.Int
+ public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+ public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+ public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.kt b/compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.kt
new file mode 100644
index 0000000..ab48e6a
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.kt
@@ -0,0 +1,13 @@
+val flag: Boolean = false
+
+fun test1(x: Int?) {
+ var z: Int? = null
+
+ z = x ?: if (flag) 42 else 239
+
+ val y = x ?: 42
+
+ z.inc()
+ y.inc()
+
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.txt b/compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.txt
new file mode 100644
index 0000000..8072ce3
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.txt
@@ -0,0 +1,12 @@
+package
+
+public fun test(/*0*/ foo: Foo): kotlin.Unit
+public fun kotlin.Int.bar(): kotlin.Int
+
+public interface Foo {
+ public abstract val length: kotlin.Int
+ public abstract val list: kotlin.collections.List<kotlin.Int>
+ public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+ public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+ public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
index 23b359b..a5d328f 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
@@ -20585,6 +20585,12 @@
doTest(fileName);
}
+ @TestMetadata("foobar.kt")
+ public void testFoobar() throws Exception {
+ String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/foobar.kt");
+ doTest(fileName);
+ }
+
@TestMetadata("genericIntersection.kt")
public void testGenericIntersection() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/genericIntersection.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestWithStdLibGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestWithStdLibGenerated.java
index 2f197b4..440021e 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestWithStdLibGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestWithStdLibGenerated.java
@@ -55,6 +55,12 @@
doTest(fileName);
}
+ @TestMetadata("dontCommitTmp.kt")
+ public void testDontCommitTmp() throws Exception {
+ String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.kt");
+ doTest(fileName);
+ }
+
@TestMetadata("elvisOnJavaList.kt")
public void testElvisOnJavaList() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java
index 76cf622..a583904 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java
@@ -55,6 +55,12 @@
doTest(fileName);
}
+ @TestMetadata("dontCommitTmp.kt")
+ public void testDontCommitTmp() throws Exception {
+ String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/dontCommitTmp.kt");
+ doTest(fileName);
+ }
+
@TestMetadata("elvisOnJavaList.kt")
public void testElvisOnJavaList() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java
index 1e6c167..80290ce 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java
@@ -20585,6 +20585,12 @@
doTest(fileName);
}
+ @TestMetadata("foobar.kt")
+ public void testFoobar() throws Exception {
+ String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/foobar.kt");
+ doTest(fileName);
+ }
+
@TestMetadata("genericIntersection.kt")
public void testGenericIntersection() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/genericIntersection.kt");
