azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FE 1.0] Migrate most of warning/error pairs to DiagnosticFactoryForDeprecation

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-07-30 13:26:35 +03:00
parent 7c73840e4a
commit d17f984edf
74 changed files with 285 additions and 411 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt
+1 -7
View File
@@ -37,13 +37,7 @@ object InconsistentOperatorFromJavaCallChecker : CallChecker {
val containingClass = callableDescriptor.containingDeclaration as? ClassDescriptor ?: continue
if (containingClass.fqNameOrNull() != CONCURRENT_HASH_MAP_FQ_NAME) continue
val diagnosticFactory =
if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitConcurrentHashMapContains))
ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR
else
ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR
context.trace.report(diagnosticFactory.on(reportOn))
context.trace.report(ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR.on(context.languageVersionSettings, reportOn))
break
}
}
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt
+2 -7
View File
@@ -51,8 +51,7 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker
isStaticDeclaration(descriptor) &&
isInterface(descriptor.containingDeclaration) &&
descriptor is JavaCallableMemberDescriptor) {
val diagnostic = if (isDefaultCallsProhibited(context)) INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_ERROR else INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET
context.trace.report(diagnostic.on(reportOn))
context.trace.report(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET.on(context.languageVersionSettings, reportOn))
}
val superCallExpression = getSuperCallExpression(resolvedCall.call) ?: return
@@ -76,9 +75,7 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker
}
if (!supportDefaults) {
val diagnostic =
if (isDefaultCallsProhibited(context)) DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR else DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET
context.trace.report(diagnostic.on(reportOn))
context.trace.report(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET.on(context.languageVersionSettings, reportOn))
}
}
}
@@ -104,8 +101,6 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker
return null
}
private fun isDefaultCallsProhibited(context: CallCheckerContext) =
context.languageVersionSettings.supportsFeature(LanguageFeature.DefaultMethodsCallFromJava6TargetError)
private fun getSuperCallLabelTarget(
bindingContext: BindingContext,
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt
+1 -6
View File
@@ -26,12 +26,7 @@ object PolymorphicSignatureCallChecker : CallChecker {
if (valueArgument !is VarargValueArgument) continue
for (argument in valueArgument.arguments) {
val spread = argument.getSpreadElement() ?: continue
val diagnostic =
if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitSpreadOnSignaturePolymorphicCall))
ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR
else
ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL
context.trace.report(diagnostic.on(spread))
context.trace.report(ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL.on(context.languageVersionSettings, spread))
}
}
}
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt
+1 -7
View File
@@ -235,13 +235,7 @@ class OverloadsAnnotationChecker : DeclarationChecker {
diagnosticHolder.report(ErrorsJvm.OVERLOADS_LOCAL.on(annotationEntry))
descriptor.isAnnotationConstructor() -> {
val diagnostic =
if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses))
ErrorsJvm.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR
else
ErrorsJvm.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_WARNING
diagnosticHolder.report(diagnostic.on(annotationEntry))
diagnosticHolder.report(ErrorsJvm.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR.on(context.languageVersionSettings, annotationEntry))
}
!descriptor.visibility.isPublicAPI && descriptor.visibility != DescriptorVisibilities.INTERNAL ->
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
+2 -7
View File
@@ -51,7 +51,6 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
MAP.put(OVERLOADS_INTERFACE, "'@JvmOverloads' annotation cannot be used on interface methods");
MAP.put(OVERLOADS_PRIVATE, "'@JvmOverloads' annotation has no effect on private declarations");
MAP.put(OVERLOADS_LOCAL, "'@JvmOverloads' annotation cannot be used on local declarations");
MAP.put(OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_WARNING, "'@JvmOverloads' annotation on constructors of annotation classes is deprecated");
MAP.put(OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR, "'@JvmOverloads' annotation cannot be used on constructors of annotation classes");
MAP.put(OVERLOADS_ANNOTATION_HIDDEN_CONSTRUCTOR, "'@JvmOverloads' annotation cannot be used on constructors hidden by inline class rules");
MAP.put(OVERLOADS_ANNOTATION_MANGLED_FUNCTION, "'@JvmOverloads' annotation cannot be used on functions mangled by inline class rules");
@@ -147,10 +146,8 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
"Please make explicit overrides (abstract or concrete) for the following non-abstract members of ''{1}'': {2}",
NAME, NAME, STRING);
MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, "Super calls to Java default methods are deprecated in JVM target 1.6. Recompile with '-jvm-target 1.8'");
MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR, "Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'");
MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET, "Calls to static methods in Java interfaces are deprecated in JVM target 1.6. Recompile with '-jvm-target 1.8'");
MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_ERROR, "Calls to static methods in Java interfaces are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'");
MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, "Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'");
MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET, "Calls to static methods in Java interfaces are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'");
MAP.put(INLINE_FROM_HIGHER_PLATFORM, "Cannot inline bytecode built with {0} into bytecode that is being built with {1}. Please specify proper ''-jvm-target'' option", STRING, STRING);
MAP.put(INLINE_FROM_HIGHER_PLATFORM_WARNING, "Cannot inline bytecode built with {0} into bytecode that is being built with {1}. Please specify proper ''-jvm-target'' option", STRING, STRING);
@@ -195,12 +192,10 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
"Use explicit form of the call to 'containsKey'/'containsValue'/'contains' or cast the value to kotlin.collections.Map instead. " +
"See https://youtrack.jetbrains.com/issue/KT-18053 for more details";
MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS);
MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS);
MAP.put(TAILREC_WITH_DEFAULTS, "Computation order of non-constant default arguments in tail-recursive functions will change in 1.4. See KT-31540 for more details");
String spreadOnPolymorphicSignature = "Spread operator is prohibited for arguments to signature-polymorphic calls";
MAP.put(SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL, spreadOnPolymorphicSignature);
MAP.put(SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR, spreadOnPolymorphicSignature);
MAP.put(FUNCTION_DELEGATE_MEMBER_NAME_CLASH,
"Functional interface member cannot have this name on JVM because it clashes with an internal member getFunctionDelegate");
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
+6 -10
View File
@@ -6,6 +6,7 @@
package org.jetbrains.kotlin.resolve.jvm.diagnostics;
import com.intellij.psi.PsiElement;
import org.jetbrains.kotlin.config.LanguageFeature;
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -58,8 +59,7 @@ public interface ErrorsJvm {
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_INTERFACE = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_PRIVATE = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_LOCAL = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_WARNING = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<KtAnnotationEntry> OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses);
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_ANNOTATION_MANGLED_FUNCTION = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtAnnotationEntry> OVERLOADS_ANNOTATION_HIDDEN_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
@@ -113,10 +113,8 @@ public interface ErrorsJvm {
DiagnosticFactory3<PsiElement, DeclarationDescriptor, DeclarationDescriptor, String> TARGET6_INTERFACE_INHERITANCE = DiagnosticFactory3.create(ERROR);
DiagnosticFactory0<PsiElement> DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<PsiElement> DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<PsiElement> INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<PsiElement> INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_ERROR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<PsiElement> DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactoryForDeprecation0.create(LanguageFeature.DefaultMethodsCallFromJava6TargetError);
DiagnosticFactoryForDeprecation0<PsiElement> INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactoryForDeprecation0.create(LanguageFeature.DefaultMethodsCallFromJava6TargetError);
DiagnosticFactory2<PsiElement, String, String> INLINE_FROM_HIGHER_PLATFORM = DiagnosticFactory2.create(ERROR);
DiagnosticFactory2<PsiElement, String, String> INLINE_FROM_HIGHER_PLATFORM_WARNING = DiagnosticFactory2.create(WARNING);
@@ -175,13 +173,11 @@ public interface ErrorsJvm {
DiagnosticFactory1<PsiElement, String> SUSPENSION_POINT_INSIDE_MONITOR = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, CallableDescriptor> SUSPENSION_POINT_INSIDE_CRITICAL_SECTION = DiagnosticFactory1.create(ERROR);
DiagnosticFactory0<PsiElement> CONCURRENT_HASH_MAP_CONTAINS_OPERATOR = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<PsiElement> CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<PsiElement> CONCURRENT_HASH_MAP_CONTAINS_OPERATOR = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitConcurrentHashMapContains);
DiagnosticFactory0<KtNamedFunction> TAILREC_WITH_DEFAULTS = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
DiagnosticFactory0<PsiElement> SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<PsiElement> SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<PsiElement> SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitSpreadOnSignaturePolymorphicCall);
DiagnosticFactory0<PsiElement> FUNCTION_DELEGATE_MEMBER_NAME_CLASH = DiagnosticFactory0.create(ERROR);
compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt
+1 -6
View File
@@ -554,12 +554,7 @@ class ControlFlowInformationProviderImpl private constructor(
}
private fun reportValReassigned(expression: KtExpression, variableDescriptor: VariableDescriptor, ctxt: VariableInitContext) {
val diagnosticFactory = if (languageVersionSettings.supportsFeature(LanguageFeature.RestrictionOfValReassignmentViaBackingField))
VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR
else
VAL_REASSIGNMENT_VIA_BACKING_FIELD
report(diagnosticFactory.on(expression, variableDescriptor), ctxt)
report(VAL_REASSIGNMENT_VIA_BACKING_FIELD.on(languageVersionSettings, expression, variableDescriptor), ctxt)
}
private fun checkAssignmentBeforeDeclaration(ctxt: VariableInitContext, expression: KtExpression) =
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+15 -28
View File
@@ -246,8 +246,7 @@ public interface Errors {
// Annotations
DiagnosticFactory0<KtSuperTypeList> SUPERTYPES_FOR_ANNOTATION_CLASS = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtAnnotationEntry> ANNOTATION_ON_SUPERCLASS = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtAnnotationEntry> ANNOTATION_ON_SUPERCLASS_WARNING = DiagnosticFactory0.create(WARNING);
DiagnosticFactoryForDeprecation0<KtAnnotationEntry> ANNOTATION_ON_SUPERCLASS = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitUseSiteTargetAnnotationsOnSuperTypes);
DiagnosticFactory0<KtParameter> MISSING_VAL_ON_ANNOTATION_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtParameter> VAR_ANNOTATION_PARAMETER = DiagnosticFactory0.create(ERROR, VAL_OR_VAR_NODE);
DiagnosticFactory0<KtCallExpression> ANNOTATION_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR);
@@ -265,11 +264,9 @@ public interface Errors {
DiagnosticFactory0<KtAnnotationEntry> ANNOTATION_USED_AS_ANNOTATION_ARGUMENT = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> ANNOTATION_ARGUMENT_IS_NON_CONST = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<PsiElement> RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<PsiElement> RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_WARNING = DiagnosticFactory0.create(WARNING);
DiagnosticFactoryForDeprecation0<PsiElement> RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION = DiagnosticFactoryForDeprecation0.create(LanguageFeature.RestrictRetentionForExpressionAnnotations);
DiagnosticFactory0<KtClassOrObject> LOCAL_ANNOTATION_CLASS = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<KtClassOrObject> LOCAL_ANNOTATION_CLASS_ERROR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<KtClassOrObject> LOCAL_ANNOTATION_CLASS = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitLocalAnnotations);
DiagnosticFactory1<PsiElement, FqName> ILLEGAL_KOTLIN_VERSION_STRING_VALUE = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, String> NEWER_VERSION_IN_SINCE_KOTLIN = DiagnosticFactory1.create(WARNING);
@@ -448,8 +445,7 @@ public interface Errors {
// Companion objects
DiagnosticFactory0<KtObjectDeclaration> MANY_COMPANION_OBJECTS = DiagnosticFactory0.create(ERROR, COMPANION_OBJECT);
DiagnosticFactory0<KtExpression> SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_WARNING = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<KtExpression> SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<KtExpression> SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitSelfCallsInNestedObjects);
// Objects
@@ -510,10 +506,9 @@ public interface Errors {
DiagnosticFactory2<PsiElement, CallableMemberDescriptor, DeclarationDescriptor> DATA_CLASS_OVERRIDE_CONFLICT =
DiagnosticFactory2.create(ERROR);
DiagnosticFactory2<PsiElement, CallableMemberDescriptor, DeclarationDescriptor> DATA_CLASS_OVERRIDE_DEFAULT_VALUES_WARNING =
DiagnosticFactory2.create(WARNING);
DiagnosticFactory2<PsiElement, CallableMemberDescriptor, DeclarationDescriptor> DATA_CLASS_OVERRIDE_DEFAULT_VALUES_ERROR =
DiagnosticFactory2.create(ERROR);
DiagnosticFactoryForDeprecation2<PsiElement, CallableMemberDescriptor, DeclarationDescriptor> DATA_CLASS_OVERRIDE_DEFAULT_VALUES =
DiagnosticFactoryForDeprecation2.create(LanguageFeature.ProhibitDataClassesOverridingCopy);
// DiagnosticFactory2.create(ERROR);
DiagnosticFactory1<KtDeclaration, CallableMemberDescriptor> CANNOT_INFER_VISIBILITY =
DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
@@ -562,10 +557,8 @@ public interface Errors {
DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
DiagnosticFactory2<KtClassOrObject, KtClassOrObject, CallableMemberDescriptor> MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED_WARNING =
DiagnosticFactory2.create(WARNING, DECLARATION_NAME);
DiagnosticFactory2<KtClassOrObject, ClassDescriptor, Collection<CallableMemberDescriptor>> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER =
DiagnosticFactory2.create(ERROR, DECLARATION_NAME);
DiagnosticFactory2<KtClassOrObject, ClassDescriptor, Collection<CallableMemberDescriptor>> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING =
DiagnosticFactory2.create(WARNING, DECLARATION_NAME);
DiagnosticFactoryForDeprecation2<KtClassOrObject, ClassDescriptor, Collection<CallableMemberDescriptor>> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER =
DiagnosticFactoryForDeprecation2.create(LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses, DECLARATION_NAME);
DiagnosticFactory1<KtDeclaration, Collection<KotlinType>> AMBIGUOUS_ANONYMOUS_TYPE_INFERRED =
DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
@@ -644,8 +637,7 @@ public interface Errors {
DiagnosticFactory0<KtParameter> VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtNamedFunction> NO_TAIL_CALLS_FOUND = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtNamedFunction> TAILREC_ON_VIRTUAL_MEMBER = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtNamedFunction> TAILREC_ON_VIRTUAL_MEMBER_ERROR = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactoryForDeprecation0<KtNamedFunction> TAILREC_ON_VIRTUAL_MEMBER = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitTailrecOnVirtualMember, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtParameter>
ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);
@@ -769,11 +761,9 @@ public interface Errors {
DiagnosticFactory1<KtExpression, KotlinType> MISSING_RECEIVER = DiagnosticFactory1.create(ERROR);
DiagnosticFactory0<KtExpression> NO_RECEIVER_ALLOWED = DiagnosticFactory0.create(ERROR);
DiagnosticFactory1<KtExpression, KotlinType> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION = DiagnosticFactory1.create(WARNING);
DiagnosticFactory1<KtExpression, KotlinType> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR = DiagnosticFactory1.create(ERROR);
DiagnosticFactoryForDeprecation1<KtExpression, KotlinType> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm);
DiagnosticFactory0<KtExpression> REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<KtExpression> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION = DiagnosticFactory0.create(WARNING);
DiagnosticFactory0<KtExpression> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR = DiagnosticFactory0.create(ERROR);
DiagnosticFactoryForDeprecation0<KtExpression> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm);
DiagnosticFactory0<KtExpression> REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION = DiagnosticFactory0.create(WARNING);
// Call resolution
@@ -797,8 +787,7 @@ public interface Errors {
DiagnosticFactory1<PsiElement, Collection<? extends CallableDescriptor>> CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, TypeParameterDescriptor> TYPE_PARAMETER_AS_REIFIED = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, TypeParameterDescriptor> TYPE_PARAMETER_AS_REIFIED_ARRAY = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, TypeParameterDescriptor> TYPE_PARAMETER_AS_REIFIED_ARRAY_WARNING = DiagnosticFactory1.create(WARNING);
DiagnosticFactoryForDeprecation1<PsiElement, TypeParameterDescriptor> TYPE_PARAMETER_AS_REIFIED_ARRAY = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProhibitNonReifiedArraysAsReifiedTypeArguments);
DiagnosticFactory1<PsiElement, KotlinType> REIFIED_TYPE_FORBIDDEN_SUBSTITUTION = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, KotlinType> REIFIED_TYPE_UNSAFE_SUBSTITUTION = DiagnosticFactory1.create(WARNING);
DiagnosticFactory0<KtElement> CANDIDATE_CHOSEN_USING_OVERLOAD_RESOLUTION_BY_LAMBDA_ANNOTATION = DiagnosticFactory0.create(WARNING);
@@ -985,8 +974,7 @@ public interface Errors {
DiagnosticFactory0<KtLambdaExpression> UNUSED_LAMBDA_EXPRESSION = DiagnosticFactory0.create(WARNING);
DiagnosticFactory1<KtExpression, DeclarationDescriptor> VAL_REASSIGNMENT = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<KtExpression, DeclarationDescriptor> VAL_REASSIGNMENT_VIA_BACKING_FIELD = DiagnosticFactory1.create(WARNING);
DiagnosticFactory1<KtExpression, DeclarationDescriptor> VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR = DiagnosticFactory1.create(ERROR);
DiagnosticFactoryForDeprecation1<KtExpression, DeclarationDescriptor> VAL_REASSIGNMENT_VIA_BACKING_FIELD = DiagnosticFactoryForDeprecation1.create(LanguageFeature.RestrictionOfValReassignmentViaBackingField);
DiagnosticFactory1<KtExpression, DeclarationDescriptor> CAPTURED_VAL_INITIALIZATION = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<KtExpression, DeclarationDescriptor> CAPTURED_MEMBER_VAL_INITIALIZATION = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<KtExpression, DeclarationDescriptor> SETTER_PROJECTED_OUT = DiagnosticFactory1.create(ERROR);
@@ -1165,9 +1153,8 @@ public interface Errors {
DiagnosticFactory0<PsiElement> NON_LOCAL_RETURN_IN_DISABLED_INLINE = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtDeclaration> INLINE_PROPERTY_WITH_BACKING_FIELD = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtAnnotationEntry> NON_INTERNAL_PUBLISHED_API = DiagnosticFactory0.create(ERROR);
DiagnosticFactory1<PsiElement, CallableDescriptor> PROTECTED_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING);
DiagnosticFactoryForDeprecation1<PsiElement, CallableDescriptor> PROTECTED_CALL_FROM_PUBLIC_INLINE = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProhibitProtectedCallFromInline);
DiagnosticFactory1<PsiElement, CallableDescriptor> PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING);
DiagnosticFactory1<PsiElement, CallableDescriptor> PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, CallableDescriptor> SUPER_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING);
DiagnosticFactory2<KtElement, KtExpression, DeclarationDescriptor> INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE = DiagnosticFactory2.create(ERROR);
DiagnosticFactory2<KtElement, KtExpression, DeclarationDescriptor> NOT_SUPPORTED_INLINE_PARAMETER_IN_INLINE_PARAMETER_DEFAULT_VALUE = DiagnosticFactory2.create(ERROR);
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+7 -20
View File
@@ -333,8 +333,7 @@ public class DefaultErrorMessages {
MAP.put(VIRTUAL_MEMBER_HIDDEN, "''{0}'' hides member of supertype ''{2}'' and needs ''override'' modifier", NAME, NAME, NAME);
MAP.put(DATA_CLASS_OVERRIDE_CONFLICT, "Function ''{0}'' generated for the data class conflicts with member of supertype ''{1}''", NAME, NAME);
MAP.put(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_WARNING, "Function ''{0}'' generated for the data class has default values for parameters, and conflicts with member of supertype ''{1}''", NAME, NAME);
MAP.put(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_ERROR, "Function ''{0}'' generated for the data class has default values for parameters, and conflicts with member of supertype ''{1}''", NAME, NAME);
MAP.put(DATA_CLASS_OVERRIDE_DEFAULT_VALUES, "Function ''{0}'' generated for the data class has default values for parameters, and conflicts with member of supertype ''{1}''", NAME, NAME);
MAP.put(CANNOT_OVERRIDE_INVISIBLE_MEMBER, "''{0}'' has no access to ''{1}'', so it cannot override it", FQ_NAMES_IN_TYPES,
FQ_NAMES_IN_TYPES);
@@ -358,8 +357,7 @@ public class DefaultErrorMessages {
MAP.put(UNUSED_LAMBDA_EXPRESSION, "The lambda expression is unused. If you mean a block, you can use 'run { ... }'");
MAP.put(VAL_REASSIGNMENT, "Val cannot be reassigned", NAME);
MAP.put(VAL_REASSIGNMENT_VIA_BACKING_FIELD, "Reassignment of read-only property via backing field is deprecated", NAME);
MAP.put(VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR, "Reassignment of read-only property via backing field", NAME);
MAP.put(VAL_REASSIGNMENT_VIA_BACKING_FIELD, "Reassignment of read-only property via backing field", NAME);
MAP.put(CAPTURED_VAL_INITIALIZATION, "Captured values initialization is forbidden due to possible reassignment", NAME);
MAP.put(CAPTURED_MEMBER_VAL_INITIALIZATION, "Captured member values initialization is forbidden due to possible reassignment", NAME);
MAP.put(SETTER_PROJECTED_OUT, "Setter for ''{0}'' is removed by type projection", NAME);
@@ -377,7 +375,6 @@ public class DefaultErrorMessages {
MAP.put(MANY_COMPANION_OBJECTS, "Only one companion object is allowed per class");
MAP.put(SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_WARNING, "Self references to members of containing class are prohibited in constructor of nested object");
MAP.put(SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR, "Self references to members of containing class are prohibited in constructor of nested object");
MAP.put(DEPRECATION, "''{0}'' is deprecated. {1}", DEPRECATION_RENDERER, STRING);
@@ -680,8 +677,7 @@ public class DefaultErrorMessages {
MAP.put(ILLEGAL_SELECTOR, "The expression cannot be a selector (occur after a dot)");
MAP.put(NO_TAIL_CALLS_FOUND, "A function is marked as tail-recursive but no tail calls are found");
MAP.put(TAILREC_ON_VIRTUAL_MEMBER, "Tailrec on open members is deprecated");
MAP.put(TAILREC_ON_VIRTUAL_MEMBER_ERROR, "Tailrec is not allowed on open members");
MAP.put(TAILREC_ON_VIRTUAL_MEMBER, "Tailrec is not allowed on open members");
MAP.put(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION, "A type annotation is required on a value parameter");
MAP.put(BREAK_OR_CONTINUE_OUTSIDE_A_LOOP, "'break' and 'continue' are only allowed inside a loop");
@@ -877,7 +873,6 @@ public class DefaultErrorMessages {
MAP.put(MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED_WARNING, "Deprecated: {0} must override {1} because it inherits multiple interface methods of it",
RENDER_CLASS_OR_OBJECT, FQ_NAMES_IN_TYPES);
MAP.put(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER, "{0} inherits invisible abstract members: {1}", NAME, commaSeparated(FQ_NAMES_IN_TYPES));
MAP.put(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING, "{0} inherits invisible abstract members: {1}", NAME, commaSeparated(FQ_NAMES_IN_TYPES));
MAP.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", commaSeparated(FQ_NAMES_IN_TYPES));
@@ -910,11 +905,9 @@ public class DefaultErrorMessages {
MAP.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", NAME);
MAP.put(MISSING_RECEIVER, "A receiver of type {0} is required", RENDER_TYPE);
MAP.put(NO_RECEIVER_ALLOWED, "No receiver can be passed to this function or property");
MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, "Assigning single elements to varargs in named form is deprecated", TO_STRING);
MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, "Assigning single elements to varargs in named form is forbidden", TO_STRING);
MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, "Assigning single elements to varargs in named form is forbidden", TO_STRING);
MAP.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION, "Redundant spread (*) operator");
MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, "Assigning single elements to varargs in named form is deprecated");
MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR, "Assigning single elements to varargs in named form is forbidden");
MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, "Assigning single elements to varargs in named form is forbidden");
MAP.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, "Redundant spread (*) operator");
MAP.put(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, "Cannot create an instance of an abstract class");
@@ -948,7 +941,6 @@ public class DefaultErrorMessages {
MAP.put(TYPE_PARAMETER_AS_REIFIED, "Cannot use ''{0}'' as reified type parameter. Use a class instead.", NAME);
MAP.put(TYPE_PARAMETER_AS_REIFIED_ARRAY, "Cannot use ''{0}'' as reified type parameter, since the array type parameter is not reified.", NAME);
MAP.put(TYPE_PARAMETER_AS_REIFIED_ARRAY_WARNING, "Cannot use ''{0}'' as reified type parameter, since the array type parameter is not reified.", NAME);
MAP.put(REIFIED_TYPE_PARAMETER_NO_INLINE, "Only type parameters of inline functions can be reified");
MAP.put(REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, "Cannot use ''{0}'' as reified type parameter", RENDER_TYPE);
MAP.put(REIFIED_TYPE_UNSAFE_SUBSTITUTION, "It may be not safe to use ''{0}'' as an argument for a reified type parameter. Use a non-generic type or * if possible", RENDER_TYPE);
@@ -983,14 +975,10 @@ public class DefaultErrorMessages {
MAP.put(RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION,
"Expression annotations with retention other than SOURCE are prohibited");
MAP.put(RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_WARNING,
"Expression annotations with retention other than SOURCE are deprecated");
MAP.put(LOCAL_ANNOTATION_CLASS, "Local annotation classes are deprecated and will be unsupported in a future release");
MAP.put(LOCAL_ANNOTATION_CLASS_ERROR, "Annotation class cannot be local");
MAP.put(LOCAL_ANNOTATION_CLASS, "Annotation class cannot be local");
MAP.put(ANNOTATION_ON_SUPERCLASS, "Annotations on superclass are meaningless");
MAP.put(ANNOTATION_ON_SUPERCLASS_WARNING, "Annotations on superclass are meaningless and deprecated");
MAP.put(CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT, "Const 'val' are only allowed on top level or in objects");
MAP.put(CONST_VAL_WITH_DELEGATE, "Const 'val' should not have a delegate");
@@ -1055,9 +1043,8 @@ public class DefaultErrorMessages {
MAP.put(RECURSION_IN_INLINE, "Inline function ''{1}'' cannot be recursive", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);
MAP.put(INLINE_PROPERTY_WITH_BACKING_FIELD, "Inline property cannot have backing field");
MAP.put(NON_INTERNAL_PUBLISHED_API, "@PublishedApi annotation is only applicable for internal declaration");
MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE, "Protected function call from public-API inline function is deprecated", NAME);
MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE, "Protected function call from public-API inline function is prohibited", NAME);
MAP.put(PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE, "Protected constructor call from public-API inline function is deprecated", NAME);
MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR, "Protected function call from public-API inline function is prohibited", NAME);
MAP.put(SUPER_CALL_FROM_PUBLIC_INLINE, "Accessing super members from public-API inline function is deprecated", NAME);
MAP.put(INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE, "Invalid default value for inline parameter: ''{0}''. Only lambdas, anonymous functions, and callable references are supported", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);
MAP.put(NOT_SUPPORTED_INLINE_PARAMETER_IN_INLINE_PARAMETER_DEFAULT_VALUE, "Usage of inline parameter ''{0}'' in default value for another inline parameter is not supported", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt
+1 -7
View File
@@ -170,13 +170,7 @@ class AnnotationChecker(
}
val actualTargets = getActualTargetList(reference, null, trace.bindingContext)
if (entry.useSiteTarget != null && isSuperType) {
val reportError = languageVersionSettings.supportsFeature(ProhibitUseSiteTargetAnnotationsOnSuperTypes)
val diagnostic = if (reportError) {
Errors.ANNOTATION_ON_SUPERCLASS.on(entry)
} else {
Errors.ANNOTATION_ON_SUPERCLASS_WARNING.on(entry)
}
trace.report(diagnostic)
trace.report(Errors.ANNOTATION_ON_SUPERCLASS.on(languageVersionSettings, entry))
} else if (shouldRunCheck && (languageVersionSettings.supportsFeature(ProperCheckAnnotationsTargetInTypeUsePositions) || checkWithoutLanguageFeature)) {
checkAnnotationEntry(entry, actualTargets, trace)
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt
+1 -5
View File
@@ -347,11 +347,7 @@ class DeclarationsChecker(
private fun checkLocalAnnotation(classDescriptor: ClassDescriptor, classOrObject: KtClassOrObject) {
if (classDescriptor.kind == ClassKind.ANNOTATION_CLASS && DescriptorUtils.isLocal(classDescriptor)) {
if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitLocalAnnotations)) {
trace.report(LOCAL_ANNOTATION_CLASS_ERROR.on(classOrObject))
} else {
trace.report(LOCAL_ANNOTATION_CLASS.on(classOrObject))
}
trace.report(LOCAL_ANNOTATION_CLASS.on(languageVersionSettings, classOrObject))
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt
+2 -10
View File
@@ -270,11 +270,7 @@ class OverrideResolver(
}
if (abstractInvisibleSuper.isNotEmpty() && !canHaveAbstractMembers) {
if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses)) {
trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER.on(klass, classDescriptor, abstractInvisibleSuper))
} else {
trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING.on(klass, classDescriptor, abstractInvisibleSuper))
}
trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER.on(languageVersionSettings, klass, classDescriptor, abstractInvisibleSuper))
}
conflictingInterfaceMembers.removeAll(conflictingReturnTypes)
@@ -410,11 +406,7 @@ class OverrideResolver(
if (overridden != null) {
val baseClassifier = overridden.containingDeclaration
val dataModifier = findDataModifierForDataClass(copyFunction.containingDeclaration)
if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitDataClassesOverridingCopy)) {
trace.report(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_ERROR.on(dataModifier, copyFunction, baseClassifier))
} else {
trace.report(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_WARNING.on(dataModifier, copyFunction, baseClassifier))
}
trace.report(DATA_CLASS_OVERRIDE_DEFAULT_VALUES.on(languageVersionSettings, dataModifier, copyFunction, baseClassifier))
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt
+10 -38
View File
@@ -8,10 +8,8 @@ package org.jetbrains.kotlin.resolve.calls.checkers
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.config.LanguageFeature.*
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.diagnostics.Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION
import org.jetbrains.kotlin.diagnostics.Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR
import org.jetbrains.kotlin.psi.KtExpression
import org.jetbrains.kotlin.psi.ValueArgument
import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isArrayOrArrayLiteral
@@ -21,18 +19,6 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.descriptorUtil.isParameterOfAnnotation
class AssigningNamedArgumentToVarargChecker : CallChecker {
companion object {
private val migrationDiagnosticsForFunction = MigrationDiagnostics(
ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION,
ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR
)
private val migrationDiagnosticsForAnnotation = MigrationDiagnostics(
Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION,
Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR
)
}
override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
for ((parameterDescriptor, resolvedArgument) in resolvedCall.valueArguments) {
for (argument in resolvedArgument.arguments) {
@@ -71,9 +57,9 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
context.trace.report(Errors.REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION.on(argumentExpression))
}
} else {
reportMigrationDiagnostic(migrationDiagnosticsForAnnotation, context) { diagnostic ->
context.trace.report(diagnostic.on(argumentExpression))
}
context.trace.report(
Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION.on(context.languageVersionSettings, argumentExpression)
)
}
}
@@ -92,30 +78,16 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
}
} else {
if (!argument.hasSpread()) {
reportMigrationDiagnostic(migrationDiagnosticsForFunction, context) { diagnostic ->
context.trace.report(diagnostic.on(argumentExpression, parameterDescriptor.type))
}
context.trace.report(
ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION.on(
context.languageVersionSettings,
argumentExpression,
parameterDescriptor.type
)
)
}
}
}
private fun ValueArgument.hasSpread() = getSpreadElement() != null
private inline fun <T : DiagnosticFactory<*>> reportMigrationDiagnostic(
migrationDiagnostics: MigrationDiagnostics<T>,
context: ResolutionContext<*>,
report: (T) -> Unit
) {
val (warning, error) = migrationDiagnostics
if (context.languageVersionSettings.supportsFeature(ProhibitAssigningSingleElementsToVarargsInNamedForm)) {
report(error)
} else {
report(warning)
}
}
}
private data class MigrationDiagnostics<T : DiagnosticFactory<*>>(val warning: T, val error: T)
private val ResolutionContext<*>.isAssigningArrayEnabled: Boolean
get() = languageVersionSettings.supportsFeature(AllowAssigningArrayElementsToVarargsInNamedFormForFunctions)
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.kt
+3 -7
View File
@@ -60,14 +60,11 @@ internal class InlineChecker(private val descriptor: FunctionDescriptor) : CallC
private var supportDefaultValueInline by Delegates.notNull<Boolean>()
private var prohibitProtectedCallFromInline by Delegates.notNull<Boolean>()
override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
val call = resolvedCall.call
val expression = call.calleeExpression ?: return
supportDefaultValueInline = context.languageVersionSettings.supportsFeature(LanguageFeature.InlineDefaultFunctionalParameters)
prohibitProtectedCallFromInline = context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitProtectedCallFromInline)
//checking that only invoke or inlinable extension called on function parameter
val targetDescriptor = resolvedCall.resultingDescriptor
@@ -282,11 +279,10 @@ internal class InlineChecker(private val descriptor: FunctionDescriptor) : CallC
isConstructorCall -> {
context.trace.report(PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE.on(expression, calledDescriptor))
}
prohibitProtectedCallFromInline -> {
context.trace.report(PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR.on(expression, calledDescriptor))
}
else -> {
context.trace.report(PROTECTED_CALL_FROM_PUBLIC_INLINE.on(expression, calledDescriptor))
context.trace.report(
PROTECTED_CALL_FROM_PUBLIC_INLINE.on(context.languageVersionSettings, expression, calledDescriptor)
)
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java
+1 -5
View File
@@ -67,11 +67,7 @@ public class ReifiedTypeParameterSubstitutionChecker implements CallChecker {
DiagnosticFactory1<PsiElement, TypeParameterDescriptor> diagnosticFactory;
if (isArrayArgumentCheck) {
if (context.getLanguageVersionSettings().supportsFeature(LanguageFeature.ProhibitNonReifiedArraysAsReifiedTypeArguments)) {
diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED_ARRAY;
} else {
diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED_ARRAY_WARNING;
}
diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED_ARRAY.chooseFactory(context.getLanguageVersionSettings());
} else {
diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED;
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SelfCallInNestedObjectConstructorChecker.kt
+4 -9
View File
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.resolve.calls.checkers
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
@@ -32,8 +33,7 @@ object SelfCallInNestedObjectConstructorChecker : CallChecker {
if (constructedObject.kind != ClassKind.OBJECT) return
val containingClass = constructedObject.containingDeclaration as? ClassDescriptor ?: return
if (candidateDescriptor.constructedClass == containingClass) {
val reportError = context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitSelfCallsInNestedObjects)
val visitor = Visitor(containingClass, context.trace, reportError)
val visitor = Visitor(containingClass, context.trace, context.languageVersionSettings)
resolvedCall.call.valueArgumentList?.accept(visitor)
}
}
@@ -41,7 +41,7 @@ object SelfCallInNestedObjectConstructorChecker : CallChecker {
private class Visitor(
val containingClass: ClassDescriptor,
val trace: BindingTrace,
val reportError: Boolean
val languageVersionSettings: LanguageVersionSettings
) : KtVisitorVoid() {
override fun visitKtElement(element: KtElement) {
element.acceptChildren(this, null)
@@ -65,12 +65,7 @@ object SelfCallInNestedObjectConstructorChecker : CallChecker {
val receiverType = receiver?.type ?: return
val receiverClass = receiverType.constructor.declarationDescriptor as? ClassDescriptor ?: return
if (DescriptorUtils.isSubclass(receiverClass, containingClass)) {
val factory = if (reportError) {
Errors.SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR
} else {
Errors.SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_WARNING
}
trace.report(factory.on(argument))
trace.report(Errors.SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR.on(languageVersionSettings, argument))
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/AnnotationClassTargetAndRetentionChecker.kt
+6 -6
View File
@@ -34,12 +34,12 @@ class AnnotationClassTargetAndRetentionChecker : DeclarationChecker {
val retentionAnnotation = descriptor.annotations.findAnnotation(StandardNames.FqNames.retention)
val targetAnnotation = descriptor.annotations.findAnnotation(StandardNames.FqNames.target)
val diagnostics =
if (context.languageVersionSettings.supportsFeature(LanguageFeature.RestrictRetentionForExpressionAnnotations))
Errors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION
else
Errors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_WARNING
context.trace.report(diagnostics.on(retentionAnnotation?.psi ?: targetAnnotation?.psi ?: declaration))
context.trace.report(
Errors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION.on(
context.languageVersionSettings,
retentionAnnotation?.psi ?: targetAnnotation?.psi ?: declaration
)
)
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TailrecFunctionChecker.kt
+2 -7
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.resolve.checkers
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.diagnostics.Errors
@@ -19,10 +18,6 @@ object TailrecFunctionChecker : DeclarationChecker {
if (descriptor.isEffectivelyFinal(false)) return
if (!context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitTailrecOnVirtualMember)) {
context.trace.report(Errors.TAILREC_ON_VIRTUAL_MEMBER.on(declaration))
} else {
context.trace.report(Errors.TAILREC_ON_VIRTUAL_MEMBER_ERROR.on(declaration))
}
context.trace.report(Errors.TAILREC_ON_VIRTUAL_MEMBER.on(context.languageVersionSettings, declaration))
}
}
}
compiler/testData/codegen/box/intrinsics/javaPrimitiveType_UnitAndNothing.kt
Vendored
+2 -2
View File
@@ -10,8 +10,8 @@ fun box(): String {
assertEquals(null, pNUnit!!::class.javaPrimitiveType)
assertEquals(null, Unit::class.javaPrimitiveType)
@Suppress("TYPE_INFERENCE_ONLY_INPUT_TYPES")
@Suppress("TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR")
assertEquals(java.lang.Void.TYPE, Nothing::class.javaPrimitiveType)
return "OK"
}
}
compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt
Vendored
+4 -4
View File
@@ -84,9 +84,9 @@ fun main(a: test.A, l: L<Map<String, Int>, Int?>, l1: L<Map<String, Int>, Int>)
a.bar(<!TYPE_MISMATCH!>l1 <!UNCHECKED_CAST!>as L<Map<String, Int>, Int?><!><!>)
a.baz1().t().containsKey("")
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(null)
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsKey<!>(null)
a.baz1().t().containsValue(1)
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsValue<!>(null)
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsValue<!>(null)
a.baz1().s().hashCode()
a.baz1().setT(l.t())
@@ -100,8 +100,8 @@ fun main(a: test.A, l: L<Map<String, Int>, Int?>, l1: L<Map<String, Int>, Int>)
a.baz2().s().hashCode()
a.baz3().t().containsKey("")
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(null)
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsKey<!>(null)
a.baz3().t().containsValue(1)
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsValue<!>(null)
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsValue<!>(null)
a.baz3().s().hashCode()
}
compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt
Vendored
+3 -3
View File
@@ -6,9 +6,9 @@
annotation class TestRetentionSource
@Target(AnnotationTarget.EXPRESSION)
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION!>@Retention(AnnotationRetention.BINARY)<!>
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_ERROR!>@Retention(AnnotationRetention.BINARY)<!>
annotation class TestRetentionBinary
@Target(AnnotationTarget.EXPRESSION)
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION!>@Retention(AnnotationRetention.RUNTIME)<!>
annotation class TestRetentionRuntime
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_ERROR!>@Retention(AnnotationRetention.RUNTIME)<!>
annotation class TestRetentionRuntime
compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt
Vendored
+2 -2
View File
@@ -6,6 +6,6 @@ interface Foo
@Target(AnnotationTarget.TYPE)
annotation class Ann
class E : <!ANNOTATION_ON_SUPERCLASS!>@field:Ann<!> <!ANNOTATION_ON_SUPERCLASS!>@get:Ann<!> <!ANNOTATION_ON_SUPERCLASS!>@set:Ann<!> <!ANNOTATION_ON_SUPERCLASS!>@setparam:Ann<!> Foo
class E : <!ANNOTATION_ON_SUPERCLASS_ERROR!>@field:Ann<!> <!ANNOTATION_ON_SUPERCLASS_ERROR!>@get:Ann<!> <!ANNOTATION_ON_SUPERCLASS_ERROR!>@set:Ann<!> <!ANNOTATION_ON_SUPERCLASS_ERROR!>@setparam:Ann<!> Foo
interface G : @Ann Foo
interface G : @Ann Foo
compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt
Vendored
+2 -2
View File
@@ -3,6 +3,6 @@
val my: Int = 1
get() {
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD!>field<!>++
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD_WARNING!>field<!>++
return field
}
}
compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt
Vendored
+5 -5
View File
@@ -4,19 +4,19 @@
abstract class Base(val baseProp: String)
open class Foo1(val prop: Int, baseProp: String) : Base(baseProp) {
companion object : Foo1(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!>)
companion object : Foo1(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!>)
}
open class Foo2(val prop: Int, baseProp: String) : Base(baseProp) {
companion object : Foo2(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!><!>)
companion object : Foo2(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!><!>)
}
open class Foo3(val prop: Int, baseProp: String) : Base(baseProp) {
companion object : Foo3(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!><!>)
companion object : Foo3(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!><!>)
}
open class Foo4(val prop: Int, baseProp: String) : Base(baseProp) {
object MyObject : Foo4(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!><!>)
object MyObject : Foo4(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!><!>)
}
open class CheckNested(a: Any) {
@@ -26,5 +26,5 @@ open class CheckNested(a: Any) {
}
open class Foo5(val prop: Int) {
object MyObject : Foo5(with(MyObject) { <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!> })
object MyObject : Foo5(with(MyObject) { <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!> })
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt
Vendored
+2 -2
View File
@@ -8,7 +8,7 @@ import java.util.HashSet
val a: MutableSet<String>? = null
get() {
if (a == null) {
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD!>field<!> = HashSet()
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD_WARNING!>field<!> = HashSet()
}
return a
}
@@ -17,7 +17,7 @@ class R {
val b: String? = null
get() {
if (b == null) {
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD!>field<!> = "b"
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD_WARNING!>field<!> = "b"
}
return b
}
compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt
Vendored
+2 -2
View File
@@ -6,8 +6,8 @@ inline fun <reified T> foo() {}
fun <T> bar() {
foo<<!TYPE_PARAMETER_AS_REIFIED!>T<!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY!>Array<T><!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY!>Array<Array<T>><!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY_ERROR!>Array<T><!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY_ERROR!>Array<Array<T>><!>>()
foo<Array<Int>>()
foo<Array<Array<Int>>>()
foo<IntArray>()
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt
Vendored
+4 -4
View File
@@ -444,7 +444,7 @@ fun poll8(): Flow<String> {
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
@@ -458,7 +458,7 @@ fun poll82(): Flow<String> {
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
@@ -486,8 +486,8 @@ fun poll86(): Flow<String> {
fun poll87(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>inv<!>
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt
Vendored
+2 -2
View File
@@ -57,14 +57,14 @@ fun poll75(): Flow<String> {
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt
Vendored
+2 -2
View File
@@ -22,14 +22,14 @@ class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt
Vendored
+4 -4
View File
@@ -445,7 +445,7 @@ fun poll8(): Flow<String> {
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
@@ -459,7 +459,7 @@ fun poll82(): Flow<String> {
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
@@ -487,8 +487,8 @@ fun poll86(): Flow<String> {
fun poll87(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>inv<!>
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt
Vendored
+2 -2
View File
@@ -274,7 +274,7 @@ fun poll8() {
}
fun poll81() {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv<!>()
}
@@ -304,7 +304,7 @@ fun poll86() {
}
fun poll87() {
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(foo7())
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(foo7())
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt
Vendored
+9 -9
View File
@@ -18,10 +18,10 @@ open class A {
protected set(value) {}
inline fun call() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>z<!>
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>z<!>
zVar
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>zVar<!> = "123"
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>zVar<!> = "123"
}
internal inline fun callFromInternal() {
@@ -32,10 +32,10 @@ open class A {
@PublishedApi
internal inline fun callFromPublished() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>z<!>
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>z<!>
zVar
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>zVar<!> = "123"
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>zVar<!> = "123"
}
protected inline fun callFromProtected() {
@@ -48,13 +48,13 @@ open class A {
class B : A() {
inline fun testB() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>test<!>()
}
}
class C : JavaClass() {
inline fun call() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>bind<!>()
}
internal inline fun callFromInternal() {
@@ -67,7 +67,7 @@ class C : JavaClass() {
@PublishedApi
internal inline fun callFromPublished() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>bind<!>()
}
}
compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt
Vendored
+16 -16
View File
@@ -22,7 +22,7 @@ import JavaInterface.testStatic
interface KotlinInterface : JavaInterface {
fun fooo() {
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER!>test<!>()
object {
@@ -51,7 +51,7 @@ interface KotlinInterface : JavaInterface {
interface KotlinInterfaceIndirectInheritance : KotlinInterface {
fun foooo() {
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER!>test<!>()
object {
@@ -76,25 +76,25 @@ interface KotlinInterfaceIndirectInheritance : KotlinInterface {
open class KotlinClass : JavaInterface {
fun foo(){
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>testOverride<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testOverride<!>()
object {
fun run () {
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
}
val property: String
get() {
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>testOverride<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testOverride<!>()
object {
fun run () {
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
return ""
@@ -103,7 +103,7 @@ open class KotlinClass : JavaInterface {
class KotlinClassIndirectInheritance : KotlinClass() {
fun foo2(){
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.test()
super.testOverride()
@@ -130,25 +130,25 @@ class KotlinClassIndirectInheritance : KotlinClass() {
class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance {
fun foo(){
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.testOverride()
object {
fun run () {
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
}
val property: String
get() {
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.testOverride()
object {
fun run () {
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
return ""
@@ -156,7 +156,7 @@ class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance {
}
fun test() {
JavaInterface.<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
JavaInterface.<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
KotlinClass().foo()
KotlinClass().property
KotlinClassIndirectInheritance2().foo()
compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt
Vendored
+3 -3
View File
@@ -5,7 +5,7 @@ import java.lang.invoke.MethodHandle
fun test(mh: MethodHandle) {
mh.invokeExact("1", "2")
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>emptyArray(), "X")
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>arrayOf("A", "B"), "C", <!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>arrayOf("D", "E"))
mh.invoke(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>arrayOf("A"))
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>emptyArray(), "X")
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>arrayOf("A", "B"), "C", <!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>arrayOf("D", "E"))
mh.invoke(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>arrayOf("A"))
}
compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt
Vendored
+2 -2
View File
@@ -1,9 +1,9 @@
// !LANGUAGE: -ProhibitLocalAnnotations
fun f() {
<!LOCAL_ANNOTATION_CLASS!>annotation class Anno<!>
<!LOCAL_ANNOTATION_CLASS_WARNING!>annotation class Anno<!>
@Anno class Local {
<!LOCAL_ANNOTATION_CLASS!>annotation <!NESTED_CLASS_NOT_ALLOWED!>class Nested<!><!>
<!LOCAL_ANNOTATION_CLASS_WARNING!>annotation <!NESTED_CLASS_NOT_ALLOWED!>class Nested<!><!>
}
}
compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ fun <T> javaClass(): Class<T> = null!!
public class AppServiceModule : AbstractModule<String>() {
inline fun <reified T> AbstractModule<Int>.bind() {
val x = <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>(javaClass<T>())
val x = <!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>bind<!>(javaClass<T>())
x checkType { _<String>() } // check that Class receiver is used instead of extension one
}
compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt
Vendored
+16 -16
View File
@@ -1,15 +1,15 @@
//!LANGUAGE: -ProhibitTailrecOnVirtualMember
open class A {
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec open fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec open fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>internal tailrec open fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>internal tailrec open fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>protected tailrec open fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>protected tailrec open fun baz(y: Int)<!> {
baz(y)
}
@@ -38,15 +38,15 @@ open class B : A() {
open class C : A() {
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun baz(y: Int)<!> {
baz(y)
}
}
@@ -66,15 +66,15 @@ object D : A() {
}
sealed class E : A() {
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun baz(y: Int)<!> {
baz(y)
}
@@ -109,15 +109,15 @@ enum class F {
}
};
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec open fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec open fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>internal tailrec open fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>internal tailrec open fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>protected tailrec open fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>protected tailrec open fun baz(y: Int)<!> {
baz(y)
}
@@ -134,15 +134,15 @@ enum class G {
G1;
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec open fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec open fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>internal tailrec open fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>internal tailrec open fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>protected tailrec open fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>protected tailrec open fun baz(y: Int)<!> {
baz(y)
}
@@ -168,4 +168,4 @@ val z = object : A() {
tailrec override fun baz(y: Int) {
baz(y)
}
}
}
compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt
Vendored
+2 -2
View File
@@ -11,7 +11,7 @@
annotation class Ann(vararg val s: String)
@Ann(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION!>"value"<!>)
@Ann(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_WARNING!>"value"<!>)
fun test1() {}
@Ann(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>arrayOf("value")<!>)
@@ -20,7 +20,7 @@ fun test2() {}
@Ann(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>["value"]<!>)
fun test3() {}
@JavaAnn(value = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION!>"value"<!>)
@JavaAnn(value = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_WARNING!>"value"<!>)
fun test4() {}
@JavaAnn("value", path = arrayOf("path"))
compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt
Vendored
+18 -18
View File
@@ -6,41 +6,41 @@ fun foo(vararg s: Int) {}
open class Cls(vararg p: Long)
fun test(i: IntArray) {
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, TYPE_MISMATCH!>i<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING, TYPE_MISMATCH!>i<!>)
foo(s = *i)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, TYPE_MISMATCH!>intArrayOf(1)<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING, TYPE_MISMATCH!>intArrayOf(1)<!>)
foo(s = *intArrayOf(1))
foo(1)
Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
class Sub : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
class Sub : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
val c = object : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>) {}
val c = object : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>) {}
foo(s = *intArrayOf(elements = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>))
foo(s = *intArrayOf(elements = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>))
}
fun anyFoo(vararg a: Any) {}
fun testAny() {
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>""<!>)
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>arrayOf("")<!>)
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>""<!>)
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>arrayOf("")<!>)
anyFoo(a = *arrayOf(""))
}
fun <T> genFoo(vararg t: T) {}
fun testGen() {
genFoo<Int>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
genFoo<Int?>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>null<!>)
genFoo<Array<Int>>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>arrayOf()<!>)
genFoo<Int>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
genFoo<Int?>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>null<!>)
genFoo<Array<Int>>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>arrayOf()<!>)
genFoo<Array<Int>>(t = *arrayOf(arrayOf()))
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>""<!>)
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>arrayOf("")<!>)
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>""<!>)
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>arrayOf("")<!>)
genFoo(t = *arrayOf(""))
}
@@ -48,12 +48,12 @@ fun manyFoo(vararg v: Int) {}
fun manyFoo(vararg s: String) {}
fun testMany(a: Any) {
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>""<!>)
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>""<!>)
<!NONE_APPLICABLE!>manyFoo<!>(a)
<!NONE_APPLICABLE!>manyFoo<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>v<!> = a)
<!NONE_APPLICABLE!>manyFoo<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>s<!> = a)
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>a as Int<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>a as String<!>)
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>a as Int<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>a as String<!>)
}
compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ public abstract class Base {
package impl
import base.*
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Impl<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Impl<!> : Base()
fun foo() {
Impl().foo()
compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt
Vendored
+3 -3
View File
@@ -28,9 +28,9 @@ package impl
import base.*
import intermediate.*
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class ImplDirectFromBase<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class ImplDirectFromBase<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object ImplObjDirectFromBase<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>object ImplObjDirectFromBase<!> : Base()
class ImplDirectFromBaseWithOverride : BaseWithOverride()
@@ -38,7 +38,7 @@ class ImplDirectFromBaseWithOverrid : Base() {
<!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun internalFoo(): String = ""
}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class ImplViaIntermediate<!> : Intermediate()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class ImplViaIntermediate<!> : Intermediate()
fun foo() {
ImplDirectFromBase().foo()
compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt
Vendored
+1 -1
View File
@@ -50,6 +50,6 @@ fun test6() = <!UNSUPPORTED!>foo<!><Nothing>()
class B<T>(val array: Array<T>)
fun <T> bar() = B<Array<T>>(<!TYPE_PARAMETER_AS_REIFIED_ARRAY!>arrayOf<!>())
fun <T> bar() = B<Array<T>>(<!TYPE_PARAMETER_AS_REIFIED_ARRAY_ERROR!>arrayOf<!>())
fun test7() = <!UNSUPPORTED!>bar<!><Nothing>()
compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
// !LANGUAGE: +ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses
annotation class A1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int = 1)
annotation class A2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor()
annotation class A1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int = 1)
annotation class A2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor()
compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt
Vendored
+2 -2
View File
@@ -3,7 +3,7 @@ interface A
class B : A
fun foo1(list: List<A>, arg: B?): Boolean {
// Type mismatch
return arg <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> list // resolved to extension
return arg <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> list // resolved to extension
}
fun foo2(list: List<A>, arg: B?): Boolean {
// FAKE: no cast needed
@@ -17,4 +17,4 @@ fun foo3(list: List<A>, arg: B?): Boolean {
fun foo4(list: List<A>, arg: B): Boolean {
// Ok
return arg in list
}
}
compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt
Vendored
+4 -4
View File
@@ -2,7 +2,7 @@ import java.util.*
fun foo() {
val al = ArrayList<String>()
al.size
al.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains<!>(1)
al.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains<!>(1)
al.contains("")
al.remove("")
@@ -10,7 +10,7 @@ fun foo() {
val hs = HashSet<String>()
hs.size
hs.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains<!>(1)
hs.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains<!>(1)
hs.contains("")
hs.remove("")
@@ -18,10 +18,10 @@ fun foo() {
val hm = HashMap<String, Int>()
hm.size
hm.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(1)
hm.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsKey<!>(1)
hm.containsKey("")
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>hm[1]<!>
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>hm[1]<!>
hm[""]
hm.remove("")
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt
Vendored
+1 -1
View File
@@ -7,6 +7,6 @@ object ChildB : Parent
fun <@kotlin.internal.OnlyInputTypes T> select(a: T, b: T) {}
fun test() {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>select<!>(ChildA, ChildB) // should be error
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>select<!>(ChildA, ChildB) // should be error
select<Any>(ChildA, ChildB) // should be ok
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt
Vendored
+3 -3
View File
@@ -15,7 +15,7 @@ fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {}
fun usage(x: CX, y: CY) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x, y) // expected err, got err
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooA<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooB<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo<!>(x, y) // expected err, got err
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>fooA<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>fooB<!>(x, y) // expected err, got ok
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@
// ISSUE: KT-29307
fun test_1(map: Map<String, String>) {
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!> // OK
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>map[42]<!> // OK
}
open class A
@@ -10,7 +10,7 @@ open class A
class B : A()
fun test_2(map: Map<A, String>) {
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!>
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>map[42]<!>
}
fun test_3(m: Map<*, String>) {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt
Vendored
+4 -4
View File
@@ -35,12 +35,12 @@ fun test_4(list: List<Out<Int>>, x: Out<Int>, y: Out<Number>, z: Out<Any>) {
fun test_5(list: List<Inv<Number>>, x: Inv<Number>, y: Inv<Int>, z: Inv<Any>) {
list.contains1(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(z)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(z)
}
fun test_6(list: List<Inv<Int>>, x: Inv<Int>, y: Inv<Number>, z: Inv<Any>) {
list.contains1(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(z)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(z)
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt
Vendored
+2 -2
View File
@@ -17,9 +17,9 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!
fun test(map: Map<Int, String>) {
val a: Int = <!TYPE_MISMATCH!>listOf(1).<!TYPE_MISMATCH!><!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>("")<!><!>
val a: Int = <!TYPE_MISMATCH!>listOf(1).<!TYPE_MISMATCH!><!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>("")<!><!>
val b: Boolean = listOf(1).contains1(1)
val c: String? = map.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>get1<!>("")
val c: String? = map.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>get1<!>("")
val d: String? = map.get1(1)
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ fun test(
invOut.onlyOut(42)
invOut.onlyOut(1L)
invOut.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>onlyOutUB<!>(<!TYPE_MISMATCH!>"str"<!>)
invOut.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>onlyOutUB<!>(<!TYPE_MISMATCH!>"str"<!>)
invStar.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>onlyOutUB<!>(0)
invOut.onlyOutUB(42)
invOut.onlyOutUB(1L)
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt
Vendored
+9 -9
View File
@@ -16,7 +16,7 @@ class Out<out T>
// -------------------------------------------------------
fun test_0(x: Inv2<in Number, out Number>, list: List<Inv2<Any, Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo<!>(x)
}
// ------------------------- Inv -------------------------
@@ -26,27 +26,27 @@ fun test_1(x: Inv<Number>, list: List<Inv<Number>>) {
}
fun test_2(x: Inv<Number>, list: List<Inv<Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_3(x: Inv<Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_4(x: Inv<in Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_5(x: Inv<in Number>, list: List<Inv<Number>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_6(x: Inv<in Number>, list: List<Inv<Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_7(x: Inv<out Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_8(x: Inv<out Number>, list: List<Inv<Number>>) {
@@ -96,7 +96,7 @@ fun test_32(x: Inv<Number>, list: List<Inv<in Int>>) {
}
fun test_33(x: Inv<Number>, list: List<Inv<in Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_34(x: Inv<Number>, list: List<Inv<out Number>>) {
@@ -104,7 +104,7 @@ fun test_34(x: Inv<Number>, list: List<Inv<out Number>>) {
}
fun test_35(x: Inv<Number>, list: List<Inv<out Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_36(x: Inv<Number>, list: List<Inv<out Any>>) {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt
Vendored
+7 -7
View File
@@ -43,11 +43,11 @@ fun testOK(first: First, bound: Bound, second: Second) {
}
fun testFail(first: First, bound: Bound, second: Second) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(InvB(first), InvB(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(Inv(first), Inv(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(Out(first), Out(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(In(first), In(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(InB(first), InB(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(Out(Inv(first)), Out(Inv(second)))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(In(Inv(first)), In(Inv(second)))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(InvB(first), InvB(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(Inv(first), Inv(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(Out(first), Out(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(In(first), In(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(InB(first), InB(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(Out(Inv(first)), Out(Inv(second)))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(In(Inv(first)), In(Inv(second)))
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
class Inv<T>
class Out<out T>
fun <T> foo(i: Inv<in T>, o: Out<T>) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>bar<!>(i, o)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>bar<!>(i, o)
}
fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv<out K>, o: Out<K>): K = TODO()
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ class D
fun test1(a: A, b: B, c: C) {
assertEquals1(a, b)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>assertEquals1<!>(b, c)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>assertEquals1<!>(b, c)
assertEquals1(3, 3)
assertEquals1(1 or 2, 2 or 1)
compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt
Vendored
+1 -1
View File
@@ -4,6 +4,6 @@
class Base<T : <!CYCLIC_GENERIC_UPPER_BOUND!>T<!>> : HashSet<T>() {
fun foo() {
<!SUPER_CANT_BE_EXTENSION_RECEIVER!>super<!>.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>remove<!>("")
<!SUPER_CANT_BE_EXTENSION_RECEIVER!>super<!>.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>remove<!>("")
}
}
compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt
Vendored
+24 -24
View File
@@ -18,24 +18,24 @@ class C : java.util.concurrent.ConcurrentHashMap<String, Int>() {
fun main() {
val hm = java.util.concurrent.ConcurrentHashMap<String, Int>()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> hm
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> hm
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> hm
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> hm
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> hm
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> hm
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> hm
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> hm
hm.contains("")
hm.contains(1)
"" in (hm as Map<String, Int>)
"" !in (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (hm as Map<String, Int>)
val a = A()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> a
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> a
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> a
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> a
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> a
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> a
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> a
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> a
' ' in a
' ' !in a
@@ -44,35 +44,35 @@ fun main() {
"" in (a as Map<String, Int>)
"" !in (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (a as Map<String, Int>)
val b = B()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> b
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> b
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> b
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> b
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> b
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> b
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> b
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> b
b.contains("")
b.contains(1)
"" in (b as Map<String, Int>)
"" !in (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (b as Map<String, Int>)
// Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird
val c = C()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> c
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> c
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> c
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> c
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> c
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> c
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> c
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> c
c.contains("")
c.contains(1)
"" in (c as Map<String, Int>)
"" !in (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (c as Map<String, Int>)
}
compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt
Vendored
+8 -8
View File
@@ -28,8 +28,8 @@ fun main() {
"" in (hm as Map<String, Int>)
"" !in (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (hm as Map<String, Int>)
val a = A()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR!>in<!> a
@@ -44,8 +44,8 @@ fun main() {
"" in (a as Map<String, Int>)
"" !in (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (a as Map<String, Int>)
val b = B()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR!>in<!> b
@@ -58,8 +58,8 @@ fun main() {
"" in (b as Map<String, Int>)
"" !in (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (b as Map<String, Int>)
// Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird
val c = C()
@@ -73,6 +73,6 @@ fun main() {
"" in (c as Map<String, Int>)
"" !in (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (c as Map<String, Int>)
}
compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.kt
Vendored
+2 -2
View File
@@ -36,7 +36,7 @@ import base.*
// TESTCASE NUMBER: 1
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case1<!> : BaseJava() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case1<!> : BaseJava() {}
fun case1() {
val v = Case1()
@@ -48,7 +48,7 @@ fun case1() {
*/
abstract class AbstractClassCase2 : BaseJava() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case2<!> : AbstractClassCase2() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case2<!> : AbstractClassCase2() {}
fun case2() {
val v = Case2()
compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.kt
Vendored
+2 -2
View File
@@ -62,7 +62,7 @@ fun case2() {
// TESTCASE NUMBER: 3
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case3<!> : BaseJava() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case3<!> : BaseJava() {}
fun case3() {
val v = Case3()
@@ -74,7 +74,7 @@ fun case3() {
*/
abstract class AbstractClassCase4 : BaseJava() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case4<!> : AbstractClassCase4() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case4<!> : AbstractClassCase4() {}
fun case4() {
val v = Case4()
compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.kt
Vendored
+4 -4
View File
@@ -69,13 +69,13 @@ fun case2() {
// TESTCASE NUMBER: 3
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case3<!> : BaseKotlin() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case3<!> : BaseKotlin() {}
fun case3() {
val v = Case3()
v.boo(true)
val o = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object<!> : BaseKotlin() {}
val o = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>object<!> : BaseKotlin() {}
}
/*
@@ -83,12 +83,12 @@ fun case3() {
*/
abstract class AbstractClassCase4 : BaseKotlin() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case4<!> : AbstractClassCase4() {}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case4<!> : AbstractClassCase4() {}
fun case4() {
val v = Case4()
v.boo(true)
val o = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object<!> : AbstractClassCase4() {}
val o = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>object<!> : AbstractClassCase4() {}
}
compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt
Vendored
+2 -2
View File
@@ -33,7 +33,7 @@ abstract class AbstractClassCase1() {
public abstract val pub1: String
}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Case1<!> : AbstractClassCase1(){
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Case1<!> : AbstractClassCase1(){
override fun prot() {}
override fun int() {
@@ -81,4 +81,4 @@ fun case2() {
a.<!INVISIBLE_MEMBER!>prot1<!>
a.<!INVISIBLE_MEMBER!>int1<!>
a.pub1
}
}
compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.kt
Vendored
+3 -3
View File
@@ -70,7 +70,7 @@ import libModule.*
// TESTCASE NUMBER: 2
class KotlinClassWithAbstractJavaClass() {
fun foo() {
val baseJava1 = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object<!> : BaseJava1() {}
val baseKotlin = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object<!> : BaseKotlin1() {}
val baseJava1 = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>object<!> : BaseJava1() {}
val baseKotlin = <!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>object<!> : BaseKotlin1() {}
}
}
}
compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg/1.kt
Vendored
+16 -16
View File
@@ -18,57 +18,57 @@ annotation class Case12_1
annotation class Case12_2
// TESTCASE NUMBER: 1
annotation class Case1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
// TESTCASE NUMBER: 2
annotation class Case2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>JvmOverloads<!> Case12_1] constructor(<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>x: Int = 10<!>)
annotation class Case2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>JvmOverloads<!> Case12_1] constructor(<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>x: Int = 10<!>)
// TESTCASE NUMBER: 3
annotation class Case3 @Case12_2 @Case12_1 @Case12_2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@`JvmOverloads`<!> @Case12_2 @Case12_2 constructor(<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>x: Int = 10<!>)
annotation class Case3 @Case12_2 @Case12_1 @Case12_2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@`JvmOverloads`<!> @Case12_2 @Case12_2 constructor(<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>x: Int = 10<!>)
// TESTCASE NUMBER: 4
annotation class Case4 @Case12_2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>JvmOverloads<!> Case12_1] @Case12_2 @Case12_2 constructor(<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>x: Int = 10<!>)
annotation class Case4 @Case12_2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>JvmOverloads<!> Case12_1] @Case12_2 @Case12_2 constructor(<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>x: Int = 10<!>)
// TESTCASE NUMBER: 5
annotation class Case5 @[<!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>JvmOverloads<!>] constructor(val x: Int)
annotation class Case5 @[<!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>JvmOverloads<!>] constructor(val x: Int)
// TESTCASE NUMBER: 6
annotation class Case6 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor()
annotation class Case6 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor()
// TESTCASE NUMBER: 7
annotation class Case7<!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor() {}
annotation class Case7<!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor() {}
// TESTCASE NUMBER: 8
annotation class Case8 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@`JvmOverloads`<!> constructor()
annotation class Case8 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@`JvmOverloads`<!> constructor()
// TESTCASE NUMBER: 9
annotation class Case9 <A, Case12_1 : A, Case12_2 : Case12_1, D : Case12_2, E : D> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case9 <A, Case12_1 : A, Case12_2 : Case12_1, D : Case12_2, E : D> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
// TESTCASE NUMBER: 10
annotation class Case10 <T> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case10 <T> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
// TESTCASE NUMBER: 11
annotation class Case11 <T : Number, K : Comparable<K>> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case11 <T : Number, K : Comparable<K>> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
// TESTCASE NUMBER: 12
annotation class Case12 <T> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int) where T: Number
annotation class Case12 <T> <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int) where T: Number
// TESTCASE NUMBER: 13
annotation class Case13 constructor(val x: Int) {
annotation class Case1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
}
// TESTCASE NUMBER: 14
annotation class Case14 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int) {
annotation class Case14 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int) {
annotation class Case1 constructor(val x: Int)
}
// TESTCASE NUMBER: 15
object Case15 {
annotation class Case15 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case15 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
}
// TESTCASE NUMBER: 16
class Case16 {
annotation class Case16 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int)
annotation class Case16 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int)
}
compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/25.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ open class Case1<K : Number> {
<!DEBUG_INFO_EXPRESSION_TYPE("L & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.get(0)
<!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.size
<!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.isEmpty()
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!><!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>[null]<!>
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!><!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>[null]<!>
}
}
}
compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/26.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ open class Case1<K : Number> {
<!DEBUG_INFO_EXPRESSION_TYPE("L & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.get(0)
<!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.size
<!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.isEmpty()
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!><!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>[null]<!>
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!><!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>[null]<!>
}
}
}
compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/27.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ open class Case1<K : Number> {
<!DEBUG_INFO_EXPRESSION_TYPE("L & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.get(0)
<!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.size
<!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>.isEmpty()
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!><!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>[null]<!>
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!><!DEBUG_INFO_EXPRESSION_TYPE("M & kotlin.Any?"), DEBUG_INFO_SMARTCAST!>x<!>[null]<!>
}
}
}
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/1.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 1
open class Foo(val prop: Int) {
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!>)
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!>)
}
fun box(): String? {
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/2.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 2
open class Foo(val prop: Int) {
companion object MyCompanion : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>Foo.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>)
companion object MyCompanion : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>Foo.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>)
}
fun box(): String? {
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/3.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 3
open class Foo(val prop: Int) {
object MyObject : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>)
object MyObject : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>)
}
fun box(): String? {
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/4.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 4
open class Foo(val prop: Int) {
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!>)
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!>)
}
fun box(): String? {
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/5.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 5
open class Foo(val prop: Int) {
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>)
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>)
}
fun box(): String? {
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/6.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 6
open class Foo(val prop: Int) {
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>)
companion object : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>)
}
fun box(): String? {
compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/7.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@
// TESTCASE NUMBER: 7
open class Foo(val prop: Int) {
object MyObject : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>)
object MyObject : Foo(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>)
}
fun box(): String? {