StreamToLoopInspection: disable for raw types (IDEA-163493), disable for unresolved method references

java/java-impl/src/com/intellij/codeInspection/streamToLoop/FunctionHelper.java

@@ -103,11 +103,13 @@ abstract class FunctionHelper {
       return new LambdaFunctionHelper(body, parameters);
     }
     if (expression instanceof PsiMethodReferenceExpression) {
-      PsiType functionalInterfaceType = ((PsiMethodReferenceExpression)expression).getFunctionalInterfaceType();
+      PsiMethodReferenceExpression methodRef = (PsiMethodReferenceExpression)expression;
+      if (methodRef.resolve() == null) return null;
+      PsiType functionalInterfaceType = methodRef.getFunctionalInterfaceType();
       PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(functionalInterfaceType);
       if (interfaceMethod == null) return null;
       if (interfaceMethod.getParameterList().getParametersCount() != paramCount) return null;
-      return new MethodReferenceFunctionHelper(functionalInterfaceType, (PsiMethodReferenceExpression)expression);
+      return new MethodReferenceFunctionHelper(functionalInterfaceType, methodRef);
     }
     if (expression instanceof PsiReferenceExpression && ExpressionUtils.isSimpleExpression(expression)) {
       PsiType functionalInterfaceType = expression.getType();

java/java-impl/src/com/intellij/codeInspection/streamToLoop/Operation.java

@@ -21,6 +21,7 @@ import com.intellij.psi.PsiMethodCallExpression;
 import com.intellij.psi.PsiType;
 import com.intellij.psi.util.PsiTypesUtil;
 import one.util.streamex.StreamEx;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
@@ -52,7 +53,8 @@ abstract class Operation {
   public void suggestNames(StreamVariable inVar, StreamVariable outVar) {}
 
   @Nullable
-  static Operation createIntermediate(String name, PsiExpression[] args, StreamVariable outVar, PsiType inType) {
+  static Operation createIntermediate(@NotNull String name, @NotNull PsiExpression[] args,
+                                      @NotNull StreamVariable outVar, @NotNull PsiType inType) {
     if(name.equals("distinct") && args.length == 0) {
       return new DistinctOperation();
     }

java/java-impl/src/com/intellij/codeInspection/streamToLoop/StreamToLoopInspection.java

@@ -132,10 +132,15 @@ public class StreamToLoopInspection extends BaseJavaBatchLocalInspectionTool {
     if(className == null) return null;
     PsiType callType = call.getType();
     if(callType == null) return null;
-    if(InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_UTIL_STREAM_BASE_STREAM)) {
+    if(InheritanceUtil.isInheritor(aClass, CommonClassNames.JAVA_UTIL_STREAM_BASE_STREAM) &&
+       !method.getModifierList().hasExplicitModifier(PsiModifier.STATIC)) {
       PsiExpression qualifier = call.getMethodExpression().getQualifierExpression();
       if(qualifier != null) {
         PsiType elementType = getStreamElementType(qualifier.getType());
+        if(elementType == null || ((elementType instanceof PsiClassType) && ((PsiClassType)elementType).isRaw())) {
+          // Raw type in any stream step is not supported
+          return null;
+        }
         Operation op = Operation.createIntermediate(name, args, outVar, elementType);
         if (op != null) return op;
         op = TerminalOperation.createTerminal(name, args, elementType, callType, call.getParent() instanceof PsiExpressionStatement);

java/java-impl/src/com/intellij/codeInspection/streamToLoop/TerminalOperation.java

@@ -63,7 +63,8 @@ abstract class TerminalOperation extends Operation {
   }
 
   @Nullable
-  static TerminalOperation createTerminal(String name, PsiExpression[] args, PsiType elementType, PsiType resultType, boolean isVoid) {
+  static TerminalOperation createTerminal(@NotNull String name, @NotNull PsiExpression[] args,
+                                          @NotNull PsiType elementType, @NotNull PsiType resultType, boolean isVoid) {
     if(isVoid) {
       if ((name.equals("forEach") || name.equals("forEachOrdered")) && args.length == 1) {
         FunctionHelper fn = FunctionHelper.create(args[0], 1, true);