Fix tests: "Placing function type parameters after the function name" error

2015-11-26 15:56:31 +03:00
parent 3001af56c9
commit a3ff3ffc45
435 changed files with 550 additions and 569 deletions
@@ -1,4 +1,4 @@
-fun foo<T: Number?>(t: T) {
+fun <T: Number?> foo(t: T) {
    (t ?: 42).toInt()
 }

@@ -1,4 +1,4 @@
-fun foo<T : Number?>(t: T) {
+fun <T : Number?> foo(t: T) {
    t?.toInt()
 }

@@ -1,6 +1,6 @@
 fun isNull(x: Unit?) = x == null

-fun isNullGeneric<T : Any>(x: T?) = x == null
+fun <T : Any> isNullGeneric(x: T?) = x == null

 fun deepIsNull0(x: Unit?) = isNull(x)
 fun deepIsNull(x: Unit?) = deepIsNull0(x)
@@ -23,7 +23,7 @@ abstract class Tag(val name: String) : Element() {
    val children = ArrayList<Element>()
    val attributes = HashMap<String, String>()

-    inline protected fun initTag<T : Element>(tag: T, init: T.() -> Unit): T {
+    inline protected fun <T : Element> initTag(tag: T, init: T.() -> Unit): T {
        tag.init()
        children.add(tag)
        return tag
@@ -47,7 +47,7 @@ abstract class Tag(val name: String) : Element() {
 }

 abstract class TagWithText(name: String) : Tag(name) {
-    fun String.plus() {
+    operator fun String.unaryPlus() {
        children.add(TextElement(this))
    }
 }
@@ -23,7 +23,7 @@ abstract class Tag(val name: String) : Element() {
    val children = ArrayList<Element>()
    val attributes = HashMap<String, String>()

-    inline protected fun initTag<T : Element>(tag: T, init: T.() -> Unit): T {
+    inline protected fun <T : Element> initTag(tag: T, init: T.() -> Unit): T {
        tag.init()
        children.add(tag)
        return tag
@@ -47,7 +47,7 @@ abstract class Tag(val name: String) : Element() {
 }

 abstract class TagWithText(name: String) : Tag(name) {
-    fun String.plus() {
+    operator fun String.unaryPlus() {
        children.add(TextElement(this))
    }
 }
@@ -1,6 +1,6 @@
 package test

-inline fun test<reified T>(x: Any): Boolean {
+inline fun <reified T> test(x: Any): Boolean {
    val x = object {
        val y = x is T
    }
@@ -1,5 +1,5 @@
 package test

-inline fun f<reified T>(x : () -> Unit) {
+inline fun <reified T> f(x : () -> Unit) {
    object { init { arrayOf<T>() } }
 }
@@ -4,7 +4,7 @@ fun <T> test2(): T {
   return a as T
 }

-fun test3<T: Any>() = null as T
+fun <T: Any> test3() = null as T

 fun box(): String {
    if (test1<Int?>() != null) return "fail: test1"
@@ -1,5 +1,5 @@

-inline fun calc<T, R>(value : T, fn: (T)->R) : R = fn(value)
+inline fun <T, R> calc(value : T, fn: (T) -> R) : R = fn(value)
 inline fun <T> identity(value : T) : T = calc(value) {
    if (1 == 1) return it
    it
@@ -1 +1 @@
-fun foo<T : Any>(t: T) = t
+fun <T : Any> foo(t: T) = t
@@ -1,4 +1,4 @@
-fun foo<T, P, E>() = 42
+fun <T, P, E> foo() = 42

 interface A
 interface B : A
@@ -8,7 +8,7 @@ class FC1: OC2(), T3
 interface T4: <!INTERFACE_WITH_SUPERCLASS!>OC1<!>
 interface T5: T2

-fun test<TP1: OC1, TP2: T2, TP3: OC2>(
+fun <TP1: OC1, TP2: T2, TP3: OC2> test(
    t2: T2,
    t4: T4,
    fc1: FC1,
@@ -6,7 +6,7 @@ open class OClass2
 class FClass1
 class FClass2

-fun test<TP1: OClass1, TP2: OClass2>(
+fun <TP1: OClass1, TP2: OClass2> test(
  t1: Trait1,
  oc1: OClass1,
  fc1: FClass1,
@@ -2,7 +2,7 @@ package test

 class MembersReferenceOuterTP<P> {
    inner class Inner {
-        fun f<Q : P>() {}
+        fun <Q : P> f() {}
        fun g(p: P): P = null!!

        val v: P = null!!
@@ -1,4 +1,4 @@
-inline fun with<T>(receiver : T, body :  T.() -> Unit) = receiver.body()
+inline fun <T> with(receiver : T, body :  T.() -> Unit) = receiver.body()

 fun example() {

@@ -9,12 +9,13 @@ JetFile: With.kt
    PsiWhiteSpace(' ')
    PsiElement(fun)('fun')
    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('with')
    TYPE_PARAMETER_LIST
      PsiElement(LT)('<')
      TYPE_PARAMETER
        PsiElement(IDENTIFIER)('T')
      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('with')
    VALUE_PARAMETER_LIST
      PsiElement(LPAR)('(')
      VALUE_PARAMETER
@@ -8,7 +8,7 @@ open class ICloseable {

 abstract class JavaCloseableWrapper(closeable : java.io.Closeable) : ICloseable(closeable)

-fun streamCopy<T>(from : IIterable<T>, to : IAdder<T>) {
+fun <T> streamCopy(from : IIterable<T>, to : IAdder<T>) {
  for (item in from) t.add(item)
 }

@@ -117,12 +117,13 @@ JetFile: IOSamples.kt
  FUN
    PsiElement(fun)('fun')
    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('streamCopy')
    TYPE_PARAMETER_LIST
      PsiElement(LT)('<')
      TYPE_PARAMETER
        PsiElement(IDENTIFIER)('T')
      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('streamCopy')
    VALUE_PARAMETER_LIST
      PsiElement(LPAR)('(')
      VALUE_PARAMETER
@@ -599,4 +600,4 @@ JetFile: IOSamples.kt
      PsiWhiteSpace(' ')
      PsiComment(EOL_COMMENT)('// throws IOException, you must catch or rethrow explicitly')
      PsiWhiteSpace('\n\n')
-      PsiElement(RBRACE)('}')
+      PsiElement(RBRACE)('}')
@@ -10,7 +10,7 @@ enum class ComparisonResult {

 typealias MatchableComparison<in T> =  (T, T) -> ComparisonResult

-fun asMatchableComparison<T>(cmp : Comparison<T>) : MatchableComparison<T> = {a, b ->
+fun <T> asMatchableComparison(cmp : Comparison<T>) : MatchableComparison<T> = {a, b ->
  val res = cmp(a, b)
  if (res == 0) return ComparisonResult.EQ
  if (res < 0) return ComparisonResult.LS
@@ -273,12 +273,13 @@ JetFile: Comparison.kt
  FUN
    PsiElement(fun)('fun')
    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('asMatchableComparison')
    TYPE_PARAMETER_LIST
      PsiElement(LT)('<')
      TYPE_PARAMETER
        PsiElement(IDENTIFIER)('T')
      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('asMatchableComparison')
    VALUE_PARAMETER_LIST
      PsiElement(LPAR)('(')
      VALUE_PARAMETER
@@ -7,5 +7,5 @@ fun ((T) -> G)?.foo()
 fun ((T) -> G)??.foo()

 //--------------
-fun f<T>()
+fun <T> f()
 a.b class C
@@ -418,12 +418,13 @@ JetFile: FunctionsWithFunctionReceivers.kt
    PsiWhiteSpace('\n')
    PsiElement(fun)('fun')
    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('f')
    TYPE_PARAMETER_LIST
      PsiElement(LT)('<')
      TYPE_PARAMETER
        PsiElement(IDENTIFIER)('T')
      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('f')
    VALUE_PARAMETER_LIST
      PsiElement(LPAR)('(')
      PsiElement(RPAR)(')')
@@ -438,4 +439,4 @@ JetFile: FunctionsWithFunctionReceivers.kt
  CLASS
    PsiElement(class)('class')
    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('C')
+    PsiElement(IDENTIFIER)('C')
@@ -19,7 +19,7 @@ c<t>.

 //-----------
 class A<X> {
-    fun foo<Y>() {
+    fun <Y> foo() {
    }
 }

@@ -537,12 +537,13 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
      FUN
        PsiElement(fun)('fun')
        PsiWhiteSpace(' ')
-        PsiElement(IDENTIFIER)('foo')
        TYPE_PARAMETER_LIST
          PsiElement(LT)('<')
          TYPE_PARAMETER
            PsiElement(IDENTIFIER)('Y')
          PsiElement(GT)('>')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
        VALUE_PARAMETER_LIST
          PsiElement(LPAR)('(')
          PsiElement(RPAR)(')')
@@ -600,4 +601,4 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
            PsiElement(LPAR)('(')
            PsiElement(RPAR)(')')
      PsiWhiteSpace('\n')
-      PsiElement(RBRACE)('}')
+      PsiElement(RBRACE)('}')
@@ -65,20 +65,20 @@ public class KotlinOverloadTest extends KotlinLiteFixture {
                "fun a() : Any");

        assertNotOverloadable(
-                "fun a<T1>() : T1",
-                "fun a<T>() : T");
+                "fun <T1> a() : T1",
+                "fun <T> a() : T");

        assertNotOverloadable(
-                "fun a<T1>(a : T1) : T1",
-                "fun a<T>(a : T) : T");
+                "fun <T1> a(a : T1) : T1",
+                "fun <T> a(a : T) : T");

        assertNotOverloadable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y : T>(a : T) : T");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y : T> a(a : T) : T");

        assertNotOverloadable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y : T>(a : T) : Y");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y : T> a(a : T) : Y");

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@@ -100,50 +100,50 @@ public class KotlinOverloadTest extends KotlinLiteFixture {
                "fun a(a : Int) : Int");

        assertNotOverloadable(
-                "fun a<T>(a : Int) : Int",
+                "fun <T> a(a : Int) : Int",
                "fun a(a : Int) : Int");

        // TODO
        /*
        assertOverloadable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y>(a : T) : T");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y> a(a : T) : T");
        */

        assertOverloadable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y : T>(a : Y) : T");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y : T> a(a : Y) : T");

        assertNotOverloadable(
-                "fun a<T1, X : T1>(a : T1) : X",
-                "fun a<T, Y : T>(a : T) : T");
+                "fun <T1, X : T1> a(a : T1) : X",
+                "fun <T, Y : T> a(a : T) : T");

        // TODO
        /*
        assertNotOverloadable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<in T>) : T");
        */

        assertOverloadable(
-                "fun a<T1, X : Array<T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<in T>) : T");

        assertOverloadable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<in T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<in T>> a(a : Array<in T>) : T");

        assertOverloadable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<*>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<*>> a(a : Array<in T>) : T");

        assertOverloadable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<out T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<out T>) : T");

        assertOverloadable(
-                "fun a<T1, X : Array<out T1>>(a : Array<*>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<*>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<in T>) : T");

        assertOverloadable(
                "fun ff() : Int",
@@ -58,20 +58,20 @@ public class KotlinOverridingTest extends KotlinLiteFixture {
                "fun a() : Int");

        assertOverridable(
-                "fun a<T1>() : T1",
-                "fun a<T>() : T");
+                "fun <T1> a() : T1",
+                "fun <T> a() : T");

        assertOverridable(
-                "fun a<T1>(a : T1) : T1",
-                "fun a<T>(a : T) : T");
+                "fun <T1> a(a : T1) : T1",
+                "fun <T> a(a : T) : T");

        assertOverridable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y : T>(a : T) : T");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y : T> a(a : T) : T");

        assertOverridable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y : T>(a : T) : Y");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y : T> a(a : T) : Y");

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@@ -104,44 +104,44 @@ public class KotlinOverridingTest extends KotlinLiteFixture {
                "fun a(a : Int) : Int");

        assertNotOverridable(
-                "fun a<T>(a : Int) : Int",
+                "fun <T> a(a : Int) : Int",
                "fun a(a : Int) : Int");

        assertNotOverridable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y>(a : T) : T");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y> a(a : T) : T");

        assertNotOverridable(
-                "fun a<T1, X : T1>(a : T1) : T1",
-                "fun a<T, Y : T>(a : Y) : T");
+                "fun <T1, X : T1> a(a : T1) : T1",
+                "fun <T, Y : T> a(a : Y) : T");

        assertOverridable(
-                "fun a<T1, X : T1>(a : T1) : X",
-                "fun a<T, Y : T>(a : T) : T");
+                "fun <T1, X : T1> a(a : T1) : X",
+                "fun <T, Y : T> a(a : T) : T");

        assertOverridable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<in T>) : T");

        assertNotOverridable(
-                "fun a<T1, X : Array<T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<in T>) : T");

        assertNotOverridable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<in T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<in T>> a(a : Array<in T>) : T");

        assertNotOverridable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<*>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<*>> a(a : Array<in T>) : T");

        assertNotOverridable(
-                "fun a<T1, X : Array<out T1>>(a : Array<in T1>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<out T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<in T1>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<out T>) : T");

        assertNotOverridable(
-                "fun a<T1, X : Array<out T1>>(a : Array<*>) : T1",
-                "fun a<T, Y : Array<out T>>(a : Array<in T>) : T");
+                "fun <T1, X : Array<out T1>> a(a : Array<*>) : T1",
+                "fun <T, Y : Array<out T>> a(a : Array<in T>) : T");

    }

@@ -33,7 +33,7 @@ public interface KType {
     * This may happen if it is a type of the type parameter with a nullable upper bound:
     *
     * ```
-     * fun foo<T>(t: T) {
+     * fun <T> foo(t: T) {
     *     // isMarkedNullable == false for t's type, but t can be null here
     * }
     * ```
@@ -99,7 +99,7 @@ fun int(v: Int) = IntValue(v, Type.INT_TYPE)
 fun long(v: Long) = LongValue(v)
 fun float(v: Float) = FloatValue(v)
 fun double(v: Double) = DoubleValue(v)
-//fun obj<T>(v: T, t: Type = if (v != null) Type.getType(v.javaClass) else Type.getType(javaClass<Any>())) = ObjectValue(v, t)
+//fun <T> obj(v: T, t: Type = if (v != null) Type.getType(v.javaClass) else Type.getType(javaClass<Any>())) = ObjectValue(v, t)

 val NULL_VALUE = ObjectValue(null, Type.getObjectType("null"))

@@ -1,5 +1,5 @@
-fun genericFoo<T>(p: Int){}
-fun genericFoo<T>(c: Char){}
+fun <T> genericFoo(p: Int){}
+fun <T> genericFoo(c: Char){}

 fun foo() {
    genericFoo<<caret>
@@ -2,4 +2,4 @@ fun foo() {
    <spot>bar<String>("x")</spot>
 }

-fun bar<T>(t: T) : T = t
+fun <T> bar(t: T) : T = t
@@ -2,4 +2,4 @@ fun foo() {
    <spot>bar("x")</spot>
 }

-fun bar<T>(t: T) : T = t
+fun <T> bar(t: T) : T = t
@@ -24,9 +24,6 @@ class TypeParams<in T1 : Any, out T2, T3 : (Int) -> Int, T4, T5 : Any?, T6 : T5,
    fun <T1> T1.withOwnParamExtension(p: T1) {
    }

-    fun T1.withOwnParamExtensionAfterName<T1>(p: T1) {
-    }
-
    val <G1> G1.withOwnParam: G1
        get() = throw IllegalStateException()

@@ -422,20 +422,3 @@ PsiJetFileStubImpl[package=test]
            USER_TYPE:[isAbsoluteInRootPackage=false]
              REFERENCE_EXPRESSION:[referencedName=kotlin]
            REFERENCE_EXPRESSION:[referencedName=Unit]
-      FUN:[fqName=test.TypeParams.withOwnParamExtensionAfterName, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=true, isExtension=true, isTopLevel=false, name=withOwnParamExtensionAfterName]
-        MODIFIER_LIST:[public final]
-        TYPE_PARAMETER_LIST:
-          TYPE_PARAMETER:[fqName=null, isInVariance=false, isOutVariance=false, name=T1]
-        TYPE_REFERENCE:
-          USER_TYPE:[isAbsoluteInRootPackage=false]
-            REFERENCE_EXPRESSION:[referencedName=T1]
-        VALUE_PARAMETER_LIST:
-          VALUE_PARAMETER:[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=p]
-            TYPE_REFERENCE:
-              USER_TYPE:[isAbsoluteInRootPackage=false]
-                REFERENCE_EXPRESSION:[referencedName=T1]
-        TYPE_REFERENCE:
-          USER_TYPE:[isAbsoluteInRootPackage=false]
-            USER_TYPE:[isAbsoluteInRootPackage=false]
-              REFERENCE_EXPRESSION:[referencedName=kotlin]
-            REFERENCE_EXPRESSION:[referencedName=Unit]
@@ -5,7 +5,7 @@ package b

 interface A<T>

-fun infer<T>(a: A<T>) : T {}
+fun <T> infer(a: A<T>) : T {}

 fun foo(nothing: Nothing?) {
    val i = infer(nothing)
@@ -4,14 +4,14 @@

 package i

-fun foo<R, T: List<R>>(r: R, list: T) {}
+fun <R, T: List<R>> foo(r: R, list: T) {}

 fun test1(i: Int, collection: Collection<Int>) {
    foo(i, collection) //error
 }

 //--------------
-fun bar<V : U, U>(v: V, u: MutableSet<U>) = u
+fun <V : U, U> bar(v: V, u: MutableSet<U>) = u

 fun test2(a: Any, s: MutableSet<String>) {
    bar(a, s) //error
@@ -21,7 +21,7 @@ fun test2(a: Any, s: MutableSet<String>) {
 interface A
 class B

-fun baz<T: R, R: B>(t: T, r: R) where T: A {
+fun <T: R, R: B> baz(t: T, r: R) where T: A {

 }

@@ -1,6 +1,6 @@
 // PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
 // OPTIONS: usages
-fun foo<T>(<caret>t: T): T {
+fun <T> foo(<caret>t: T): T {
    println(t)
    return t
 }
@@ -1,6 +1,6 @@
 package testing

-private fun times<T>(times : Int, body : () -> T) {}
+private fun <T> times(times : Int, body : () -> T) {}

 fun main(args: Array<String>) {
    times(3) {
@@ -1,6 +1,6 @@
 package testing

-private fun times<T>(times : Int, body : () -> T) {}
+private fun <T> times(times : Int, body : () -> T) {}

 fun main(args: Array<String>) {
    times(3) {<caret>}
@@ -64,7 +64,7 @@ class C {
    fun willBeInfix(i: Int) {}
 }

-fun typed<T>() {
+fun <T> typed() {
 }

 fun <T : Cloneable> withTypeParameters() where T : Comparable<T> {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    <caret>do doSomething("test")
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    do {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    if (true) doSomething("test")
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    if (true) doSomething("test")
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    for (i in 1..4)
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    for (i in 1..4) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    <caret>if (true) doSomething("test") else doSomething("test2")
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    if (true) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    <caret>if (true) doSomething("test")
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    if (true) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    <caret>if (true) doSomething("test");
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    if (true) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    <caret>while (true)
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    while (true) {
@@ -1,6 +1,6 @@
 // IS_APPLICABLE: false

-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun foo() {
    <caret>if (true) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String = ""
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String = ""
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    if (n == 1) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    if (n == 1) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    <caret>if (n == 1) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    <caret>return if (n == 1) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    <caret>if (n == 1) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    <caret>return if (n == 1) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String = ""
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String = ""
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    if (3 > 2) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    if (3 > 2) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    <caret>when (n) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    <caret>return when (n) {
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val foo: String? = null
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun maybeFoo(): String? {
    return "foo"
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun maybeFoo(): String? {
    return "foo"
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val foo: String? = null
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val foo: String? = "abc"
@@ -2,7 +2,7 @@ fun maybeFoo(): String? {
    return "foo"
 }

-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val foo = maybeFoo()
@@ -2,7 +2,7 @@ fun maybeFoo(): String? {
    return "foo"
 }

-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val foo = maybeFoo()
@@ -1,5 +1,5 @@
 // IS_APPLICABLE: false
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val foo: String? = "abc"
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 class Foo {
    val b: String?
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 class Foo {
    val b: String?
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val a: String? = "A"
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    val a: String? = "A"
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    var a: String? = "A"
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun main(args: Array<String>) {
    var a: String? = "A"
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 val a: String? = "A"
 fun main(args: Array<String>) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 val a: String? = "A"
 fun main(args: Array<String>) {
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 val a: String?
    get() = ""
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 val a: String?
    get() = ""
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
@@ -1,4 +1,4 @@
-fun doSomething<T>(a: T) {}
+fun <T> doSomething(a: T) {}

 fun test(n: Int): String {
    var res: String
--- a/Show More
+++ b/Show More