wip

Author: DedSec256

src/Compiler/Checking/ConstraintSolver.fs

@@ -3184,6 +3184,13 @@ and SolveTypeEqualsTypeWithReport (csenv: ConstraintSolverEnv) ndeep m trace cxs
         (fun () -> SolveTypeEqualsTypeKeepAbbrevsWithCxsln csenv ndeep m trace cxsln expectedTy actualTy)
         (function
         | AbortForFailedMemberConstraintResolution as err -> ErrorD err
+        | ConstraintSolverTypesNotInEqualityRelation (_, ty1, ty2, _, _, _) as err ->
+            let isEqual =  typeEquiv csenv.g expectedTy ty1 && typeEquiv csenv.g actualTy ty2
+            let expectedTy, actualTy =
+                if isEqual then expectedTy, actualTy
+                else ty2, ty1
+
+            ErrorD (ErrorFromAddingTypeEquation(csenv.g, csenv.DisplayEnv, expectedTy, actualTy, err, m))
         | res -> ErrorD (ErrorFromAddingTypeEquation(csenv.g, csenv.DisplayEnv, expectedTy, actualTy, res, m)))
 
 and ArgsMustSubsumeOrConvert 

src/Compiler/Driver/CompilerDiagnostics.fs

@@ -771,27 +771,27 @@ type Exception with
             if m.StartLine <> m2.StartLine then
                 os.AppendString(SeeAlsoE().Format(stringOfRange m2))
 
-        | ErrorFromAddingTypeEquation(g, denv, ty1, ty2, ConstraintSolverTypesNotInEqualityRelation(_, ty1b, ty2b, m, _, contextInfo), _) when
-            typeEquiv g ty1 ty1b && typeEquiv g ty2 ty2b
-            ->
-            let ty1, ty2, tpcs = NicePrint.minimalStringsOfTwoTypes denv ty1 ty2
+        | ErrorFromAddingTypeEquation(g,
+                                      denv,
+                                      ty1,
+                                      ty2,
+                                      (ConstraintSolverTypesNotInEqualityRelation(_, ty1b, ty2b, m, _, contextInfo) as e),
+                                      _) ->
+            if not (typeEquiv g ty1 ty1b && typeEquiv g ty2 ty2b) then
+                e.Output(os, suggestNames)
+            else
 
-            OutputTypesNotInEqualityRelationContextInfo contextInfo ty1 ty2 m os (fun contextInfo ->
-                match contextInfo with
-                | ContextInfo.TupleInRecordFields ->
-                    os.AppendString(ErrorFromAddingTypeEquation1E().Format ty2 ty1 tpcs)
-                    os.AppendString(Environment.NewLine + FSComp.SR.commaInsteadOfSemicolonInRecord ())
-                | _ when ty2 = "bool" && ty1.EndsWithOrdinal(" ref") ->
-                    os.AppendString(ErrorFromAddingTypeEquation1E().Format ty2 ty1 tpcs)
-                    os.AppendString(Environment.NewLine + FSComp.SR.derefInsteadOfNot ())
-                | _ -> os.AppendString(ErrorFromAddingTypeEquation1E().Format ty2 ty1 tpcs))
-
-        | ErrorFromAddingTypeEquation(_, _, _, _, (ConstraintSolverTypesNotInEqualityRelation(_, _, _, _, _, contextInfo) as e), _) when
-            (match contextInfo with
-             | ContextInfo.NoContext -> false
-             | _ -> true)
-            ->
-            e.Output(os, suggestNames)
+                let ty1, ty2, tpcs = NicePrint.minimalStringsOfTwoTypes denv ty1 ty2
+
+                OutputTypesNotInEqualityRelationContextInfo contextInfo ty1 ty2 m os (fun contextInfo ->
+                    match contextInfo with
+                    | ContextInfo.TupleInRecordFields ->
+                        os.AppendString(ErrorFromAddingTypeEquation1E().Format ty2 ty1 tpcs)
+                        os.AppendString(Environment.NewLine + FSComp.SR.commaInsteadOfSemicolonInRecord ())
+                    | _ when ty2 = "bool" && ty1.EndsWithOrdinal(" ref") ->
+                        os.AppendString(ErrorFromAddingTypeEquation1E().Format ty2 ty1 tpcs)
+                        os.AppendString(Environment.NewLine + FSComp.SR.derefInsteadOfNot ())
+                    | _ -> os.AppendString(ErrorFromAddingTypeEquation1E().Format ty2 ty1 tpcs))
 
         | ErrorFromAddingTypeEquation(error = ConstraintSolverTypesNotInSubsumptionRelation _ as e) -> e.Output(os, suggestNames)
 

src/Compiler/Symbols/FSharpDiagnostic.fs

@@ -199,7 +199,7 @@ type FSharpDiagnostic(m: range, severity: FSharpDiagnosticSeverity, message: str
 
             match diagnostic.Exception with
             | ErrorFromAddingTypeEquation(_, displayEnv, expectedType, actualType, ConstraintSolverTupleDiffLengths(contextInfo = contextInfo), _)
-            | ErrorFromAddingTypeEquation(_, displayEnv, _, _, ConstraintSolverTypesNotInEqualityRelation(_, expectedType, actualType, _, _, contextInfo), _)
+            | ErrorFromAddingTypeEquation(_, displayEnv, expectedType, actualType, ConstraintSolverTypesNotInEqualityRelation(_, _, _, _, _, contextInfo), _)
             | ErrorsFromAddingSubsumptionConstraint(_, displayEnv, expectedType, actualType, _, contextInfo, _) ->
                let context = DiagnosticContextInfo.From(contextInfo)
                Some(TypeMismatchDiagnosticExtendedData(symbolEnv, displayEnv, expectedType, actualType, context))

tests/FSharp.Compiler.ComponentTests/ErrorMessages/ExtendedDiagnosticDataTests.fs

@@ -4,7 +4,6 @@
 open FSharp.Compiler.Text
 open FSharp.Compiler.Diagnostics
 open FSharp.Compiler.Diagnostics.ExtendedData
-open FSharp.Test
 open FSharp.Test.Compiler
 open Xunit
 
@@ -144,16 +143,12 @@ if true then 1 else "a"
         Assert.Equal("int", typeMismatch.ExpectedType.Format(displayContext))
         Assert.Equal("string", typeMismatch.ActualType.Format(displayContext)))
 
-[<Theory>]
-[<InlineData("""
+[<Fact>]
+let ``TypeMismatchDiagnosticExtendedData 08`` () =
+    FSharp """
 type R = { Field1: int }
 let f (x: R) = "" + x.Field1
-""")>]
-[<InlineData("""
-let x: string = 1
-""")>]
-let ``TypeMismatchDiagnosticExtendedData 08`` code =
-    FSharp code
+"""
     |> typecheckResults
     |> checkDiagnostic
        (1, "The type 'int' does not match the type 'string'")
@@ -163,6 +158,20 @@ let ``TypeMismatchDiagnosticExtendedData 08`` code =
         Assert.Equal("string", typeMismatch.ExpectedType.Format(displayContext))
         Assert.Equal("int", typeMismatch.ActualType.Format(displayContext)))
 
+[<Fact>]
+let ``TypeMismatchDiagnosticExtendedData 09`` () =
+    FSharp """
+let x: string = 1
+"""
+    |> typecheckResults
+    |> checkDiagnostic
+       (1, "This expression was expected to have type\n    'string'    \nbut here has type\n    'int'    ")
+       (fun (typeMismatch: TypeMismatchDiagnosticExtendedData) ->
+        let displayContext = typeMismatch.DisplayContext
+        Assert.Equal(DiagnosticContextInfo.NoContext, typeMismatch.ContextInfo)
+        Assert.Equal("string", typeMismatch.ExpectedType.Format(displayContext))
+        Assert.Equal("int", typeMismatch.ActualType.Format(displayContext)))
+
 [<Theory>]
 [<InlineData true>]
 [<InlineData false>]