move some error and warning tests to NUnit (#7244)

* move some error and warning tests to NUnit

* CompilerAssert.ParseWithErrors now uses ParseFile instead of ParseAndCheckFileInProject

* merge conflicts

tests/fsharp/Compiler/CompilerAssert.fs

@@ -217,3 +217,22 @@ module CompilerAssert =
                     Assert.AreEqual(expectedErrorMessage, errorMessage)
                 )
 
+    let ParseWithErrors (source: string) expectedParseErrors = 
+        let parseResults = checker.ParseFile("test.fs", SourceText.ofString source, FSharpParsingOptions.Default) |> Async.RunSynchronously
+
+        Assert.True(parseResults.ParseHadErrors)
+
+        let errors = 
+            parseResults.Errors
+            |> Array.distinctBy (fun e -> e.Severity, e.ErrorNumber, e.StartLineAlternate, e.StartColumn, e.EndLineAlternate, e.EndColumn, e.Message)
+
+        Assert.AreEqual(Array.length expectedParseErrors, errors.Length, sprintf "Type check errors: %A" parseResults.Errors)
+
+        Array.zip errors expectedParseErrors
+        |> Array.iter (fun (info, expectedError) ->
+            let (expectedServerity: FSharpErrorSeverity, expectedErrorNumber: int, expectedErrorRange: int * int * int * int, expectedErrorMsg: string) = expectedError
+            Assert.AreEqual(expectedServerity, info.Severity)
+            Assert.AreEqual(expectedErrorNumber, info.ErrorNumber, "expectedErrorNumber")
+            Assert.AreEqual(expectedErrorRange, (info.StartLineAlternate, info.StartColumn + 1, info.EndLineAlternate, info.EndColumn + 1), "expectedErrorRange")
+            Assert.AreEqual(expectedErrorMsg, info.Message, "expectedErrorMsg")
+        )

tests/fsharp/Compiler/ErrorMessages/AssignmentErrorTests.fs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.UnitTests
+
+open NUnit.Framework
+open FSharp.Compiler.SourceCodeServices
+
+[<TestFixture>]
+module ``Errors assigning to mutable objects`` =
+
+    [<Test>]
+    let ``Assign to immutable error``() =
+        CompilerAssert.TypeCheckSingleError
+            """
+let x = 10
+x <- 20
+    
+exit 0
+            """
+            FSharpErrorSeverity.Error
+            27
+            (3, 1, 3, 8)
+            "This value is not mutable. Consider using the mutable keyword, e.g. 'let mutable x = expression'."

tests/fsharp/Compiler/Warnings/AssignmentWarningTests.fs

@@ -0,0 +1,108 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.UnitTests
+
+open NUnit.Framework
+open FSharp.Compiler.SourceCodeServices
+
+[<TestFixture>]
+module ``Warnings assigning to mutable and immutable objects`` =
+
+    [<Test>]
+    let ``Unused compare with immutable when assignment might be intended``() =
+        CompilerAssert.TypeCheckSingleError
+            """
+let x = 10
+let y = "hello"
+
+let changeX() =
+    x = 20
+    y = "test"
+    
+exit 0
+            """
+            FSharpErrorSeverity.Warning
+            20
+            (6, 5, 6, 11)
+            "The result of this equality expression has type 'bool' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to mutate a value, then mark the value 'mutable' and use the '<-' operator e.g. 'x <- expression'."
+
+    [<Test>]
+    let ``Unused compare with mutable when assignment might be intended``() =
+        CompilerAssert.TypeCheckSingleError
+            """
+let mutable x = 10
+let y = "hello"
+
+let changeX() =
+    x = 20
+    y = "test"
+    
+exit 0
+            """
+            FSharpErrorSeverity.Warning
+            20
+            (6, 5, 6, 11)
+            "The result of this equality expression has type 'bool' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to mutate a value, then use the '<-' operator e.g. 'x <- expression'."
+
+    [<Test>]
+    let ``Unused comparison of property in dotnet object when assignment might be intended``() =
+        CompilerAssert.TypeCheckSingleError
+            """
+open System
+
+let z = new System.Timers.Timer()
+let y = "hello"
+
+let changeProperty() =
+    z.Enabled = true
+    y = "test"
+
+exit 0
+            """
+            FSharpErrorSeverity.Warning
+            20
+            (8, 5, 8, 21)
+            "The result of this equality expression has type 'bool' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to set a value to a property, then use the '<-' operator e.g. 'z.Enabled <- expression'."
+
+    [<Test>]
+    let ``Unused comparison of property when assignment might be intended ``() =
+        CompilerAssert.TypeCheckSingleError
+            """
+type MyClass(property1 : int) =
+    member val Property1 = property1
+    member val Property2 = "" with get, set
+    
+let x = MyClass(1)
+let y = "hello"
+
+let changeProperty() =
+    x.Property2 = "20"
+    y = "test"
+    
+exit 0
+            """
+            FSharpErrorSeverity.Warning
+            20
+            (10, 5, 10, 23)
+            "The result of this equality expression has type 'bool' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to set a value to a property, then use the '<-' operator e.g. 'x.Property2 <- expression'."
+
+    [<Test>]
+    let ``Don't warn if assignment to property without setter ``() =
+        CompilerAssert.TypeCheckSingleError
+            """
+type MyClass(property1 : int) =
+    member val Property2 = "" with get
+    
+let x = MyClass(1)
+let y = "hello"
+
+let changeProperty() =
+    x.Property2 = "22"
+    y = "test"
+    
+exit 0
+            """
+            FSharpErrorSeverity.Warning
+            20
+            (9, 5, 9, 23)
+            "The result of this equality expression has type 'bool' and is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'."

tests/fsharp/FSharpSuite.Tests.fsproj

@@ -38,13 +38,15 @@
     <Compile Include="Compiler\ErrorMessages\MissingElseBranch.fs" />
     <Compile Include="Compiler\ErrorMessages\NameResolutionTests.fs" />
     <Compile Include="Compiler\ErrorMessages\UpcastDowncastTests.fs" />
+    <Compile Include="Compiler\ErrorMessages\AssignmentErrorTests.fs" />
     <Compile Include="Compiler\ErrorMessages\WarnExpressionTests.fs" />
     <Compile Include="Compiler\SourceTextTests.fs" />
     <Compile Include="Compiler\Language\AnonRecordTests.fs" />
     <Compile Include="Compiler\Language\SpanOptimizationTests.fs" />
     <Compile Include="Compiler\Language\SpanTests.fs" />
     <Compile Include="Compiler\Language\StringConcatOptimizationTests.fs" />
     <Compile Include="Compiler\Stress\LargeExprTests.fs" />
+    <Compile Include="Compiler\Warnings\AssignmentWarningTests.fs" />
     <Content Include="packages.config" />
     <None Include="app.config" />
     <None Include="update.base.line.with.actuals.fsx" />

tests/fsharpqa/Source/Warnings/env.lst

@@ -32,7 +32,6 @@
 	SOURCE=MatchingMethodWithSameNameIsNotAbstract.fs # MatchingMethodWithSameNameIsNotAbstract.fs
 	SOURCE=NoMatchingAbstractMethodWithSameName.fs # NoMatchingAbstractMethodWithSameName.fs
 	SOURCE=MissingExpressionAfterLet.fs # MissingExpressionAfterLet.fs
-	SOURCE=AssignmentOnImmutable.fs # AssignmentOnImmutable.fs
 	SOURCE=SuggestFieldsInCtor.fs # SuggestFieldsInCtor.fs
 	SOURCE=FieldSuggestion.fs # FieldSuggestion.fs
 	SOURCE=SuggestToUseIndexer.fs # SuggestToUseIndexer.fs

tests/fsharpqa/Source/test.lst

@@ -264,7 +264,6 @@ Misc01			Libraries\Core\Operators
 Misc01			Libraries\Core\Reflection
 Misc01			Libraries\Core\Unchecked
 Misc01			Warnings
-Misc01			ErrorMessages\NameResolution
 Misc01			ErrorMessages\UnitGenericAbstractType
 Misc01			ErrorMessages\ConfusingTypeName