diff --git a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
index 7f2dfe5..610516a 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
@@ -59,6 +59,7 @@
 import static org.codehaus.groovy.runtime.DefaultGroovyMethods.plus;
 import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf;
 import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.isUnboundedWildcard;
+import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.resolveClassNodeGenerics;
 
 /**
  * Utility methods to deal with parameterized types.
@@ -909,6 +910,7 @@
      *
      * @since 3.0.0
      */
+    @Deprecated(forRemoval = true, since = "5.0.0")
     public static Map<GenericsType, GenericsType> makeDeclaringAndActualGenericsTypeMap(final ClassNode declaringClass, final ClassNode actualReceiver) {
         return correlateTypeParametersAndTypeArguments(declaringClass, actualReceiver, false);
     }
@@ -924,10 +926,12 @@
      *
      * @since 3.0.0
      */
+    @Deprecated(forRemoval = true, since = "5.0.0")
     public static Map<GenericsType, GenericsType> makeDeclaringAndActualGenericsTypeMapOfExactType(final ClassNode declaringClass, final ClassNode actualReceiver) {
         return correlateTypeParametersAndTypeArguments(declaringClass, actualReceiver, true);
     }
 
+    @Deprecated(forRemoval = true, since = "5.0.0")
     private static Map<GenericsType, GenericsType> correlateTypeParametersAndTypeArguments(final ClassNode declaringClass, final ClassNode actualReceiver, final boolean tryToFindExactType) {
         ClassNode parameterizedType = findParameterizedTypeFromCache(declaringClass, actualReceiver, tryToFindExactType);
         if (parameterizedType != null && parameterizedType.isRedirectNode() && !parameterizedType.isGenericsPlaceHolder()) { // GROOVY-10166
@@ -1049,14 +1053,20 @@
      */
     public static Tuple2<ClassNode[], ClassNode> parameterizeSAM(final ClassNode samType) {
         MethodNode abstractMethod = ClassHelper.findSAM(samType);
+        ClassNode  declaringClass = abstractMethod.getDeclaringClass();
+        Map<GenericsType.GenericsTypeName, GenericsType> spec = extractPlaceholders(
+            samType.equals(declaringClass) ? samType : parameterizeType(samType, declaringClass));
 
-        Map<GenericsType, GenericsType> generics = makeDeclaringAndActualGenericsTypeMapOfExactType(abstractMethod.getDeclaringClass(), samType);
-        Function<ClassNode , ClassNode> resolver = t -> {
-            return t.isGenericsPlaceHolder() ? findActualTypeByGenericsPlaceholderName(t.getUnresolvedName(), generics) : t;
-        };
+        if (spec.isEmpty() && declaringClass.getGenericsTypes() != null) {
+            for (GenericsType tp : declaringClass.getGenericsTypes()) // apply erasure
+                spec.put(new GenericsType.GenericsTypeName(tp.getName()), erasure(tp));
+        } else {
+            // resolveClassNodeGenerics converts "T=? super Type" to Object, so convert "T=? super Type" to "T=Type"
+            spec.replaceAll((name, type) -> type.isWildcard() && type.getLowerBound() != null ? type.getLowerBound().asGenericsType() : type);
+        }
 
-        ClassNode[] parameterTypes = Arrays.stream(abstractMethod.getParameters()).map(Parameter::getType).map(resolver).toArray(ClassNode[]::new);
-        ClassNode returnType = resolver.apply(abstractMethod.getReturnType());
+        ClassNode[] parameterTypes = Arrays.stream(abstractMethod.getParameters()).map(p -> resolveClassNodeGenerics(spec, null, p.getType())).toArray(ClassNode[]::new);
+        ClassNode returnType = resolveClassNodeGenerics(spec, null, abstractMethod.getReturnType());
         return new Tuple2<>(parameterTypes, returnType);
     }
 
@@ -1068,6 +1078,7 @@
      *
      * @since 3.0.0
      */
+    @Deprecated(forRemoval = true, since = "5.0.0")
     public static ClassNode findActualTypeByGenericsPlaceholderName(final String placeholderName, final Map<GenericsType, GenericsType> genericsPlaceholderAndTypeMap) {
         Function<GenericsType, ClassNode> resolver = gt -> {
             if (gt.isWildcard()) {
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/sc/AbstractFunctionalInterfaceWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/sc/AbstractFunctionalInterfaceWriter.java
index d34c64f..df110a1 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/sc/AbstractFunctionalInterfaceWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/sc/AbstractFunctionalInterfaceWriter.java
@@ -89,63 +89,39 @@
         return arguments;
     }
 
+    default ClassNode convertParameterType(final ClassNode parameterType, final ClassNode inferredType) {
+        return convertParameterType(parameterType, parameterType, inferredType);
+    }
+
     default ClassNode convertParameterType(final ClassNode targetType, final ClassNode parameterType, final ClassNode inferredType) {
         if (!getWrapper(inferredType).isDerivedFrom(getWrapper(parameterType))) {
             throw new RuntimeParserException("The inferred type[" + inferredType.redirect() + "] is not compatible with the parameter type[" + parameterType.redirect() + "]", parameterType);
         }
 
-        ClassNode type;
-        boolean isParameterTypePrimitive = isPrimitiveType(parameterType);
-        boolean isInferredTypePrimitive = isPrimitiveType(inferredType);
-        if (!isParameterTypePrimitive && isInferredTypePrimitive) {
-            if (isDynamicTyped(parameterType) && isPrimitiveType(targetType) // (1)
-                    || !parameterType.equals(getUnwrapper(parameterType)) && !inferredType.equals(getWrapper(inferredType)) // (2)
-            ) {
-                // GROOVY-9790: bootstrap method initialization exception raised when lambda parameter type is wrong
-                // (1) java.lang.invoke.LambdaConversionException: Type mismatch for instantiated parameter 0: class java.lang.Integer is not a subtype of int
-                // (2) java.lang.BootstrapMethodError: bootstrap method initialization exception
-                type = inferredType;
-            } else {
+        ClassNode type = inferredType;
+        if (isPrimitiveType(parameterType)) {
+            if (!isPrimitiveType(inferredType)) {
+                // The non-primitive type and primitive type are not allowed to mix since Java 9+
+                // java.lang.invoke.LambdaConversionException: Type mismatch for instantiated parameter 0: class java.lang.Integer is not a subtype of int
+                type = getUnwrapper(inferredType);
+            }
+        } else if (isPrimitiveType(inferredType)) {
+            // GROOVY-9790: bootstrap method initialization exception raised when lambda parameter type is wrong
+            // (1) java.lang.invoke.LambdaConversionException: Type mismatch for instantiated parameter 0: class java.lang.Integer is not a subtype of int
+            // (2) java.lang.BootstrapMethodError: bootstrap method initialization exception
+            if (!(isDynamicTyped(parameterType) && isPrimitiveType(targetType)) // (1)
+                    && (parameterType.equals(getUnwrapper(parameterType)) || inferredType.equals(getWrapper(inferredType)))) { // (2)
                 // The non-primitive type and primitive type are not allowed to mix since Java 9+
                 // java.lang.invoke.LambdaConversionException: Type mismatch for instantiated parameter 0: int is not a subtype of class java.lang.Object
                 type = getWrapper(inferredType);
             }
-        } else if (isParameterTypePrimitive && !isInferredTypePrimitive) {
-            // The non-primitive type and primitive type are not allowed to mix since Java 9+
-            // java.lang.invoke.LambdaConversionException: Type mismatch for instantiated parameter 0: class java.lang.Integer is not a subtype of int
-            type = getUnwrapper(inferredType);
-        } else {
-            type = inferredType;
+        }
+        if (type.isGenericsPlaceHolder()) {
+            type = type.redirect();
         }
         return type;
     }
 
-    /**
-     * @deprecated use {@link #convertParameterType(ClassNode, ClassNode, ClassNode)} instead
-     */
-    @Deprecated
-    default ClassNode convertParameterType(final ClassNode parameterType, final ClassNode inferredType) {
-        if (!getWrapper(inferredType.redirect()).isDerivedFrom(getWrapper(parameterType.redirect()))) {
-            throw new RuntimeParserException("The inferred type[" + inferredType.redirect() + "] is not compatible with the parameter type[" + parameterType.redirect() + "]", parameterType);
-        } else {
-            boolean isParameterTypePrimitive = isPrimitiveType(parameterType);
-            boolean isInferredTypePrimitive = isPrimitiveType(inferredType);
-            ClassNode type;
-            if (!isParameterTypePrimitive && isInferredTypePrimitive) {
-                if (parameterType != getUnwrapper(parameterType) && inferredType != getWrapper(inferredType)) {
-                    type = inferredType;
-                } else {
-                    type = getWrapper(inferredType);
-                }
-            } else if (isParameterTypePrimitive && !isInferredTypePrimitive) {
-                type = getUnwrapper(inferredType);
-            } else {
-                type = inferredType;
-            }
-            return type;
-        }
-    }
-
     default Parameter prependParameter(final List<Parameter> parameterList, final String parameterName, final ClassNode parameterType) {
         Parameter parameter = new Parameter(parameterType, parameterName);
         parameter.setClosureSharedVariable(false);
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesMethodReferenceExpressionWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesMethodReferenceExpressionWriter.java
index faaead5..d28cfde 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesMethodReferenceExpressionWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticTypesMethodReferenceExpressionWriter.java
@@ -303,13 +303,11 @@
 
         if (inferredParamTypes != null) {
             for (int i = 0, n = parameters.length; i < n; i += 1) {
-                ClassNode inferredParamType = inferredParamTypes[i];
+                ClassNode inferredParamType = i < inferredParamTypes.length ? inferredParamTypes[i] : parameters[i].getType();
                 if (inferredParamType == null) continue;
-
                 Parameter parameter = parameters[i];
-                Parameter targetParameter = parameter;
 
-                ClassNode type = convertParameterType(targetParameter.getType(), parameter.getType(), inferredParamType);
+                ClassNode type = convertParameterType(parameter.getType(), inferredParamType);
                 parameter.setOriginType(type);
                 parameter.setType(type);
             }
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
index fddbf43..3b4b14d 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -1917,7 +1917,7 @@
         }
 
         if (type.getGenericsTypes()[0] != gt[0]) { // convert T to X
-            ClassNode cn = make(gt[0].getName()) , erasure = getCombinedBoundType(gt[0]);
+            ClassNode cn = make(gt[0].getName()) , erasure = getCombinedBoundType(gt[0]).redirect();
             cn.setGenericsPlaceHolder(true);
             cn.setGenericsTypes(gt);
             cn.setRedirect(erasure);
diff --git a/src/test/groovy/transform/stc/LambdaTest.groovy b/src/test/groovy/transform/stc/LambdaTest.groovy
index 6a03bfe..790e289 100644
--- a/src/test/groovy/transform/stc/LambdaTest.groovy
+++ b/src/test/groovy/transform/stc/LambdaTest.groovy
@@ -774,17 +774,17 @@
     void testFunctionalInterface4() {
         assertScript shell, '''
             class Value<V> {
-                final V val
+                final V val;
                 Value(V v) {
                     this.val = v
                 }
                 String toString() {
                     val as String
                 }
-                def <T> Value<T> replace(Supplier<T> supplier) {
+                def <Out> Value<Out> replace(Supplier<Out> supplier) {
                     new Value<>(supplier.get())
                 }
-                def <T> Value<T> replace(Function<? super V, ? extends T> function) {
+                def <Out> Value<Out> replace(Function<? super V, ? extends Out> function) {
                     new Value<>(function.apply(val))
                 }
             }
@@ -806,6 +806,44 @@
         assert err =~ /Expected type java.util.List<java.lang.String> for lambda parameter: list/
     }
 
+    @Test // GROOVY-11013
+    void testFunctionalInterface6() {
+        assertScript shell, '''
+            interface I<T> {
+                def m(List<T> list_of_t)
+            }
+
+            I<String> face = (List<String> list) -> null
+        '''
+    }
+
+    @Test // GROOVY-11072
+    void testFunctionalInterface7() {
+        assertScript shell, '''
+            class Model {
+            }
+            class Table<T extends Model> {
+                interface ChunkReader<T> {
+                    void call(List<T> row)
+                }
+                void getAll(ChunkReader<T> reader) {
+                    List<T> chunk = []
+                    reader.call(chunk)
+                }
+            }
+            class TestModel extends Model {
+                int id = 0
+            }
+            class TestTable extends Table<TestModel> {
+            }
+
+            TestTable table = new TestTable()
+            table.getAll((List<TestModel> list) ->
+                list.each { TestModel tm -> println(tm.id) }
+            )
+        '''
+    }
+
     @Test
     void testFunctionWithUpdatingLocalVariable() {
         assertScript shell, '''