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

Binary and unary expression support

Browse Source
This commit is contained in:
Mikhael Bogdanov
2013-12-02 16:05:51 +04:00
parent 431e61ef74
commit 621a4002e4
16 changed files with 426 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java
+11
View File
@@ -641,6 +641,7 @@ public class JetPsiUtil {
return null;
}
private static int getPriority(@NotNull JetExpression expression) {
int maxPriority = JetExpressionParsing.Precedence.values().length + 1;
@@ -1033,4 +1034,14 @@ public class JetPsiUtil {
public static boolean isLocal(@NotNull JetNamedDeclaration declaration) {
return getEnclosingBlockForLocalDeclaration(declaration) != null;
}
@Nullable
public static JetToken getOperationToken(@NotNull JetOperationExpression expression) {
JetSimpleNameExpression operationExpression = expression.getOperationReference();
IElementType elementType = operationExpression.getReferencedNameElementType();
assert elementType == null || elementType instanceof JetToken :
"JetOperationExpression should have operation token of type JetToken: " +
expression;
return (JetToken) elementType;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/InlineCallResolverExtension.java
+19 -8
View File
@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.lang.InlineUtil;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lexer.JetTokens;
import java.util.HashSet;
import java.util.Set;
@@ -103,21 +104,31 @@ public class InlineCallResolverExtension implements CallResolverExtension {
while (parent != null) {
if (parent instanceof JetValueArgument ||
parent instanceof JetBinaryExpression ||
parent instanceof JetUnaryExpression ||
parent instanceof JetDotQualifiedExpression ||
parent instanceof JetCallExpression) {
parent instanceof JetCallExpression ||
parent instanceof JetArrayAccessExpression ||
parent instanceof JetMultiDeclaration) {
if (parent instanceof JetPrefixExpression) {
if (JetPsiUtil.isLabeledExpression((JetPrefixExpression) parent)) {
parent = parent.getParent();
continue;
}
}
else if (parent instanceof JetBinaryExpression) {
if (JetPsiUtil.getOperationToken((JetOperationExpression) parent) == JetTokens.EQ) {
//assignment
return false;
}
}
//check that it's in inlineable call would be in resolve call of parent
return true;
}
else if (parent instanceof JetParenthesizedExpression || parent instanceof JetBinaryExpressionWithTypeRHS) {
parent = parent.getParent();
}
else if (parent instanceof JetPrefixExpression) {
boolean isLabeled = JetPsiUtil.isLabeledExpression((JetPrefixExpression) parent);
if (!isLabeled) {
return false;
}
parent = parent.getParent();
}
else {
return false;
}
compiler/testData/diagnostics/tests/inline/assignment.kt
+14
View File
@@ -0,0 +1,14 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
var d = <!USAGE_IS_NOT_INLINABLE!>s<!>
d = <!USAGE_IS_NOT_INLINABLE!>s<!>
var e = <!USAGE_IS_NOT_INLINABLE!>ext<!>
e = <!USAGE_IS_NOT_INLINABLE!>ext<!>
}
inline fun Function1<Int, Unit>.inlineExt() {
var d = <!USAGE_IS_NOT_INLINABLE!>this<!>
d = <!USAGE_IS_NOT_INLINABLE!>this<!>
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.kt
+27
View File
@@ -0,0 +1,27 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun <T, U> Function1<T, U>.get(index : Int) {
}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.get(index : Int) {
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s[1]
ext[1]
}
//noinline
fun <T, U, V> Function2<T, U, V>.get(index : Int) {
}
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.get(index : Int) {
}
inline fun <T, U, V, W> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: U, l: V) -> W) {
<!USAGE_IS_NOT_INLINABLE!>s<!>[1]
<!USAGE_IS_NOT_INLINABLE!>ext<!>[1]
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.kt
+30
View File
@@ -0,0 +1,30 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
fun <T, U> Function1<T, U>.minusAssign(p: Function1<T, U>) {}
inline fun <T, U> Function1<T, U>.modAssign(p: Function1<T, U>) = {
this += p
p += this
}
inline fun <T, U> Function1<T, U>.plusAssign(p: Function1<T, U>) {
<!USAGE_IS_NOT_INLINABLE!>this<!> -= <!USAGE_IS_NOT_INLINABLE!>p<!>
<!USAGE_IS_NOT_INLINABLE!>p<!> -= <!USAGE_IS_NOT_INLINABLE!>this<!>
}
fun <T, U, V> ExtensionFunction1<T, U, V>.minusAssign(ext : ExtensionFunction1<T, U, V>) {}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.modAssign(ext : ExtensionFunction1<T, U, V>) = {
this += ext
ext += this
}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.plusAssign(ext : ExtensionFunction1<T, U, V>) {
<!USAGE_IS_NOT_INLINABLE!>this<!> -= <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> -= <!USAGE_IS_NOT_INLINABLE!>this<!>
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s += s
ext += ext
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.kt
+32
View File
@@ -0,0 +1,32 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun <T, U> Function1<T, U>.compareTo(p: Function1<T, U>) = 1
inline fun <T, U, V> ExtensionFunction1<T, U, V>.compareTo(index : ExtensionFunction1<T, U, V>) = 1
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s < s
s <= s
s > s
s >= s
ext < ext
ext > ext
ext <= ext
ext >= ext
}
//noinline
fun <T, U, V> Function2<T, U, V>.compareTo(index : Function2<T, U, V>) = 1
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.compareTo(index : ExtensionFunction2<T, U, V, W>) = 1
inline fun <T, U, V, W> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: U, l: V) -> W) {
<!USAGE_IS_NOT_INLINABLE!>s<!> < <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!> <= <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!> > <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!> >= <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> < <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> > <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> <= <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> >= <!USAGE_IS_NOT_INLINABLE!>ext<!>
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.kt
+22
View File
@@ -0,0 +1,22 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun <T, U> Function1<T, U>.component1() = 1
inline fun <T, U> Function1<T, U>.component2() = 2
inline fun <T, U, V> ExtensionFunction1<T, U, V>.component1() = 1
inline fun <T, U, V> ExtensionFunction1<T, U, V>.component2() = 2
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
val (d1, e1) = s
val (d2, e2) = ext
}
fun <T, U, V> Function2<T, U, V>.component1() = 1
fun <T, U, V> Function2<T, U, V>.component2() = 2
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.component1() = 1
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.component2() = 2
inline fun <T, U, V, W> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: U, l: V) -> W) {
val (d1, e1) = <!USAGE_IS_NOT_INLINABLE, USAGE_IS_NOT_INLINABLE!>s<!>
val (d2, e2) = <!USAGE_IS_NOT_INLINABLE, USAGE_IS_NOT_INLINABLE!>ext<!>
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.kt
+34
View File
@@ -0,0 +1,34 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun <T, U> Function1<T, U>.contains(p: Function1<T, U>): Boolean {
this in p
p in this
return false
}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.contains(ext: ExtensionFunction1<T, U, V>): Boolean {
ext in this
this in ext
return false
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s in s
s !in s
ext in ext
ext !in ext
}
fun <T, U, V> Function2<T, U, V>.contains(p: Function2<T, U, V>): Boolean = false
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.contains(ext: ExtensionFunction2<T, U, V, W>): Boolean = false
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T, l: U) -> U, ext: T.(p: U, l: U) -> V) {
<!USAGE_IS_NOT_INLINABLE!>s<!> in <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!> !in <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> in <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> !in <!USAGE_IS_NOT_INLINABLE!>ext<!>
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.kt
+34
View File
@@ -0,0 +1,34 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
fun <T, U> Function1<T, U>.minus(p: Function1<T, U>) {
}
fun <T, U, V> ExtensionFunction1<T, U, V>.minus(p: T.(p: U) -> V) {
}
inline fun <T, U> Function1<T, U>.plus(p: Function1<T, U>) {
<!USAGE_IS_NOT_INLINABLE!>this<!> - <!USAGE_IS_NOT_INLINABLE!>p<!>
}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.plus(p: T.(p: U) -> V) {
<!USAGE_IS_NOT_INLINABLE!>this<!> - <!USAGE_IS_NOT_INLINABLE!>p<!>
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s + s
ext + ext
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s + s
ext + ext
}
inline fun <T, U> Function1<T, U>.submit() {
this + this
}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.submit() {
this + this
}
compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.kt
+39
View File
@@ -0,0 +1,39 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun <T, U> Function1<T, U>.rangeTo(p: Function1<T, U>): Range<Int> {
this..p
p..this
return 1..2
}
inline fun <T, U, V> ExtensionFunction1<T, U, V>.rangeTo(ext: ExtensionFunction1<T, U, V>): Range<Int> {
ext..this
this..ext
return 1..2
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
s..s
s..s
ext..ext
ext..ext
}
fun <T, U, V> Function2<T, U, V>.rangeTo(p: Function2<T, U, V>): Range<Int> {
return 1..2
}
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.rangeTo(ext: ExtensionFunction2<T, U, V, W>): Range<Int> {
return 1..2
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T, l: U) -> U, ext: T.(p: U, l: U) -> V) {
<!USAGE_IS_NOT_INLINABLE!>s<!>..<!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!>..<!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!>..<!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!>..<!USAGE_IS_NOT_INLINABLE!>ext<!>
}
compiler/testData/diagnostics/tests/inline/nullabilityOperations.kt
+16
View File
@@ -0,0 +1,16 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNNECESSARY_SAFE_CALL -UNNECESSARY_NOT_NULL_ASSERTION
inline fun String.submit(action: Function1<Int, Int>) {
}
inline fun Function1<Int, Int>.submit() {
<!USAGE_IS_NOT_INLINABLE!>this<!>?.invoke(11)
<!USAGE_IS_NOT_INLINABLE!>this<!>!!.invoke(11)
submit(<!USAGE_IS_NOT_INLINABLE!>this<!>!!)
}
inline fun submit(action: Function1<Int, Int>) {
<!USAGE_IS_NOT_INLINABLE!>action<!>?.invoke(10)
<!USAGE_IS_NOT_INLINABLE!>action<!>!!.invoke(10)
}
compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.kt
+35
View File
@@ -0,0 +1,35 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -VAL_REASSIGNMENT -UNUSED_CHANGED_VALUE -VARIABLE_EXPECTED
inline fun <T, V> Function1<T, V>.plus() = <!USAGE_IS_NOT_INLINABLE!>this<!>
fun <T, V> Function1<T, V>.minus() = this
inline fun <T, V> Function1<T, V>.inc() = <!USAGE_IS_NOT_INLINABLE!>this<!>
fun <T, V> Function1<T, V>.dec() = this
inline fun <T, V> ExtensionFunction1<T, T, V>.plus(){}
fun <T, V> ExtensionFunction1<T, T, V>.minus(){}
inline fun <T, V> ExtensionFunction1<T, T, V>.inc() = <!USAGE_IS_NOT_INLINABLE!>this<!>
fun <T, V> ExtensionFunction1<T, T, V>.dec() = this
inline fun <T, V> inlineFunWithInvoke(s: (p: T) -> V, ext: T.(p: T) -> V) {
+s
-<!USAGE_IS_NOT_INLINABLE!>s<!>
s++
++s
<!USAGE_IS_NOT_INLINABLE!>s<!>--
--<!USAGE_IS_NOT_INLINABLE!>s<!>
+ext
-<!USAGE_IS_NOT_INLINABLE!>ext<!>
ext++
++ext
<!USAGE_IS_NOT_INLINABLE!>ext<!>--
--<!USAGE_IS_NOT_INLINABLE!>ext<!>
}
inline fun <T, V> Function1<T, V>.inlineFunWithInvoke() {
+this
-<!USAGE_IS_NOT_INLINABLE!>this<!>
this++
++this
<!USAGE_IS_NOT_INLINABLE!>this<!>--
--<!USAGE_IS_NOT_INLINABLE!>this<!>
}
compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.kt
+26
View File
@@ -0,0 +1,26 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
inline fun <T, V> Function1<T, V>.not() : Boolean {
return !this
}
inline fun <T, V> ExtensionFunction1<T, T, V>.not() : Boolean {
return !this
}
inline fun <T, V> inlineFunWithInvoke(s: (p: T) -> V, ext: T.(p: T) -> V) {
!s
!ext
}
fun <T, U, V> Function2<T, U, V>.not() : Boolean {
return !this
}
fun <T, U, V, W> ExtensionFunction2<T, U, V, W>.not() : Boolean {
return !this
}
inline fun <T, U, V> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: T, l : U) -> V) {
!<!USAGE_IS_NOT_INLINABLE!>s<!>
!<!USAGE_IS_NOT_INLINABLE!>ext<!>
}
compiler/testData/diagnostics/tests/inline/wrongUsage.kt
+10 -14
View File
@@ -1,12 +1,11 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -NOTHING_TO_INLINE -USELESS_ELVIS
inline fun inlineFunWrongUsage(s: (p: Int) -> Unit) {
<!USAGE_IS_NOT_INLINABLE!>s<!>
if (true) <!USAGE_IS_NOT_INLINABLE!>s<!> else 0
var c = <!USAGE_IS_NOT_INLINABLE!>s<!>
c = <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!> ?: <!USAGE_IS_NOT_INLINABLE!>s<!>
}
inline fun inlineFunWrongUsageExt(ext: Int.(p: Int) -> Unit) {
@@ -14,8 +13,7 @@ inline fun inlineFunWrongUsageExt(ext: Int.(p: Int) -> Unit) {
if (true) <!USAGE_IS_NOT_INLINABLE!>ext<!> else 0
var c = <!USAGE_IS_NOT_INLINABLE!>ext<!>
c = <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> ?: <!USAGE_IS_NOT_INLINABLE!>ext<!>
}
inline fun inlineFunWrongUsageInClosure(s: (p: Int) -> Unit) {
@@ -24,8 +22,7 @@ inline fun inlineFunWrongUsageInClosure(s: (p: Int) -> Unit) {
if (true) <!USAGE_IS_NOT_INLINABLE!>s<!> else 0
var c = <!USAGE_IS_NOT_INLINABLE!>s<!>
c = <!USAGE_IS_NOT_INLINABLE!>s<!>
<!USAGE_IS_NOT_INLINABLE!>s<!> ?: <!USAGE_IS_NOT_INLINABLE!>s<!>
}()
}
@@ -35,21 +32,20 @@ inline fun inlineFunWrongUsageInClosureExt(ext: Int.(p: Int) -> Unit) {
if (true) <!USAGE_IS_NOT_INLINABLE!>ext<!> else 0
var c = <!USAGE_IS_NOT_INLINABLE!>ext<!>
c = <!USAGE_IS_NOT_INLINABLE!>ext<!>
<!USAGE_IS_NOT_INLINABLE!>ext<!> ?: <!USAGE_IS_NOT_INLINABLE!>ext<!>
}()
}
inline fun inlineFunNoInline(noinline s: (p: Int) -> Unit) {
s
if (true) s else 0
var c = s
c = s
s ?: s
}
inline fun inlineFunNoInline(noinline ext: Int.(p: Int) -> Unit) {
ext
if (true) ext else 0
var c = ext
c = ext
}
ext ?: ext
}
compiler/testData/diagnostics/tests/inline/wrongUsage2.kt
-24
View File
@@ -1,24 +0,0 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -UNNECESSARY_SAFE_CALL -UNNECESSARY_NOT_NULL_ASSERTION
public inline fun assertNot(message: String, block: ()-> Boolean) {}
public inline fun assertNot(block: ()-> Boolean) : Unit = assertNot(<!USAGE_IS_NOT_INLINABLE!>block<!>.toString(), block)
public fun <T> callable(action: ()-> T) {
}
public inline fun <T> String.submit(action: ()->T) {
callable(<!USAGE_IS_NOT_INLINABLE!>action<!>)
}
public inline fun <T> Function1<Int, Int>.submit() {
<!USAGE_IS_NOT_INLINABLE!>this<!>?.invoke(11)
<!USAGE_IS_NOT_INLINABLE, USAGE_IS_NOT_INLINABLE!>this<!>!!.invoke(11)
}
public inline fun <T> submit(action: Function1<Int, Int>) {
<!USAGE_IS_NOT_INLINABLE!>action<!>?.invoke(10)
<!USAGE_IS_NOT_INLINABLE, USAGE_IS_NOT_INLINABLE!>action<!>!!.invoke(10)
}
compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java
+77 -9
View File
@@ -3751,12 +3751,17 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
}
@TestMetadata("compiler/testData/diagnostics/tests/inline")
@InnerTestClasses({Inline.NonPublicMember.class})
@InnerTestClasses({Inline.BinaryExpressions.class, Inline.NonPublicMember.class, Inline.UnaryExpressions.class})
public static class Inline extends AbstractDiagnosticsTestWithEagerResolve {
public void testAllFilesPresentInInline() throws Exception {
JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.+)\\.kt$"), true);
}
@TestMetadata("assignment.kt")
public void testAssignment() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/assignment.kt");
}
@TestMetadata("capture.kt")
public void testCapture() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/capture.kt");
@@ -3782,21 +3787,26 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
doTest("compiler/testData/diagnostics/tests/inline/invoke.kt");
}
@TestMetadata("nonVirtualMembersWithInline.kt")
public void testNonVirtualMembersWithInline() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.kt");
}
@TestMetadata("labeled.kt")
public void testLabeled() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/labeled.kt");
}
@TestMetadata("nonVirtualMembersWithInline.kt")
public void testNonVirtualMembersWithInline() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.kt");
}
@TestMetadata("nothingToInline.kt")
public void testNothingToInline() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/nothingToInline.kt");
}
@TestMetadata("nullabilityOperations.kt")
public void testNullabilityOperations() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/nullabilityOperations.kt");
}
@TestMetadata("nullableFunction.kt")
public void testNullableFunction() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/nullableFunction.kt");
@@ -3837,9 +3847,47 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
doTest("compiler/testData/diagnostics/tests/inline/wrongUsage.kt");
}
@TestMetadata("wrongUsage2.kt")
public void testWrongUsage2() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/wrongUsage2.kt");
@TestMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions")
public static class BinaryExpressions extends AbstractDiagnosticsTestWithEagerResolve {
public void testAllFilesPresentInBinaryExpressions() throws Exception {
JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.+)\\.kt$"), true);
}
@TestMetadata("arrayAccess.kt")
public void testArrayAccess() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.kt");
}
@TestMetadata("assignment.kt")
public void testAssignment() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.kt");
}
@TestMetadata("comparison.kt")
public void testComparison() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.kt");
}
@TestMetadata("componentAccess.kt")
public void testComponentAccess() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.kt");
}
@TestMetadata("contains.kt")
public void testContains() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.kt");
}
@TestMetadata("mathOperations.kt")
public void testMathOperations() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.kt");
}
@TestMetadata("rangeTo.kt")
public void testRangeTo() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.kt");
}
}
@TestMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember")
@@ -3875,10 +3923,30 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
}
@TestMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions")
public static class UnaryExpressions extends AbstractDiagnosticsTestWithEagerResolve {
public void testAllFilesPresentInUnaryExpressions() throws Exception {
JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.+)\\.kt$"), true);
}
@TestMetadata("mathOperation.kt")
public void testMathOperation() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.kt");
}
@TestMetadata("notOperation.kt")
public void testNotOperation() throws Exception {
doTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.kt");
}
}
public static Test innerSuite() {
TestSuite suite = new TestSuite("Inline");
suite.addTestSuite(Inline.class);
suite.addTestSuite(BinaryExpressions.class);
suite.addTestSuite(NonPublicMember.class);
suite.addTestSuite(UnaryExpressions.class);
return suite;
}
}