Simplified compiler test framework

tests/fsharp/Compiler/ConstraintSolver/MemberConstraints.fs → tests/FSharp.Compiler.ComponentTests/ConstraintSolver/MemberConstraints.fs

@@ -1,27 +1,35 @@
-// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
 
-namespace FSharp.Compiler.UnitTests
+namespace FSharp.Compiler.ConstraintSolver.ComponentTests
 
-open NUnit.Framework
-open FSharp.Test.Utilities
-open FSharp.Compiler.SourceCodeServices
+open Xunit
+open FSharp.Test.Utilities.Compiler
 
-[<TestFixture>]
 module MemberConstraints =
 
-    [<Test>]
-    let ``we can overload operators on a type and not add all the extra jazz such as inlining and the ^ operator.``() = 
-        CompilerAssert.CompileExeAndRun
-            """
-type Foo(x : int) = 
+    [<Fact>]
+    let ``Invalid member constraint with ErrorRanges``() = // Regression test for FSharp1.0:2262
+        FSharp """
+ let inline length (x: ^a) : int = (^a : (member Length : int with get, set) (x, ()))
+        """
+        |> withOptions ["--test:ErrorRanges"]
+        |> typecheck
+        |> shouldFail
+        |> withSingleDiagnostic (Error 697, Line 2, Col 43, Line 2, Col 76, "Invalid constraint")
+
+    [<Fact>]
+    let ``we can overload operators on a type and not add all the extra jazz such as inlining and the ^ operator.``() =
+
+        FSharp """
+type Foo(x : int) =
     member this.Val = x
-    
+
     static member (-->) ((src : Foo), (target : Foo)) = new Foo(src.Val + target.Val)
     static member (-->) ((src : Foo), (target : int)) = new Foo(src.Val + target)
-    
+
     static member (+) ((src : Foo), (target : Foo)) = new Foo(src.Val + target.Val)
     static member (+) ((src : Foo), (target : int)) = new Foo(src.Val + target)
-    
+
 let x = Foo(3) --> 4
 let y = Foo(3) --> Foo(4)
 let x2 = Foo(3) + 4
@@ -32,16 +40,8 @@ elif y.Val <> 7 then  failwith "y.Val <> 7"
 elif x2.Val <> 7 then  failwith "x2.Val <> 7"
 elif y2.Val <> 7 then  failwith "x.Val <> 7"
 else ()
-            """
-
-    [<Test>]
-    let ``Invalid member constraint with ErrorRanges``() = // Regression test for FSharp1.0:2262
-        CompilerAssert.TypeCheckSingleErrorWithOptions
-            [| "--test:ErrorRanges" |]
-            """
-let inline length (x: ^a) : int = (^a : (member Length : int with get, set) (x, ()))
-            """
-            FSharpErrorSeverity.Error
-            697
-            (2, 42, 2, 75)
-            "Invalid constraint"
+        """
+        |> asExe
+        |> compile
+        |> run
+        // OR |> compileAsExeAndRun

tests/fsharp/Compiler/ConstraintSolver/PrimitiveConstraints.fs → tests/FSharp.Compiler.ComponentTests/ConstraintSolver/PrimitiveConstraints.fs

@@ -1,18 +1,27 @@
 // Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
 
-namespace FSharp.Compiler.UnitTests
+namespace FSharp.Compiler.ConstraintSolver.ComponentTests
 
-open NUnit.Framework
-open FSharp.Test.Utilities
-open FSharp.Compiler.SourceCodeServices
+open Xunit
+open FSharp.Test.Utilities.Compiler
 
-[<TestFixture>]
 module PrimitiveConstraints =
 
-    [<Test>]
+    [<Fact>]
+    /// Title: Type checking oddity
+    ///
+    /// This suggestion was resolved as by design,
+    /// so the test makes sure, we're emitting error message about 'not being a valid object construction expression'
+    let ``Invalid object constructor`` () = // Regression test for FSharp1.0:4189
+        baseline
+            ((__SOURCE_DIRECTORY__ ++ "../testables/"), "typecheck/constructors/neg_invalid_constructor.fs")
+            |> withOptions ["--test:ErrorRanges"]
+            |> typecheck
+
+
+    [<Fact>]
     let ``Test primitive : constraints``() =
-        CompilerAssert.CompileExeAndRun
-            """
+        FSharp"""
 #light
 
 type Foo(x : int) =
@@ -33,12 +42,12 @@ let b = new Bar(256)
 if test1 f <> 128       then failwith "test1 f <> 128"
 elif test2 b <> (-1, 256) then failwith "test2 b <> (-1, 256)"
 else ()
-"""
+        """
+        |> compileExeAndRun
 
-    [<Test>]
+    [<Fact>]
     let ``Test primitive :> constraints``() =
-        CompilerAssert.CompileExeAndRun
-            """
+        FSharp"""
 #light
 type Foo(x : int) =
     member   this.Value      = x
@@ -64,12 +73,12 @@ if test f <> (128, "Foo") then failwith "test f <> (128, 'Foo')"
 elif test b <> (-1, "Bar") then failwith "test b <> (-1, 'Bar')"
 elif test r <> (10, "Ram") then failwith "test r <> (10, 'Ram')"
 else ()
-"""
+        """
+        |> compileExeAndRun
 
-    [<Test>]
+    [<Fact>]
     let ``Test primitive : null constraint``() =
-        CompilerAssert.CompileExeAndRun
-            """
+        FSharp"""
 let inline isNull<'a when 'a : null> (x : 'a) =
     match x with
     | null -> "is null"
@@ -84,12 +93,5 @@ let runTest =
     with _ -> reraise()
 
 runTest
-"""
-
-    [<Test>]
-    /// Title: Type checking oddity
-    ///
-    /// This suggestion was resolved as by design,
-    /// so the test makes sure, we're emitting error message about 'not being a valid object construction expression'
-    let ``Invalid object constructor``() = // Regression test for FSharp1.0:4189
-        CompilerAssert.TypeCheckWithErrorsAndOptionsAgainstBaseLine [| "--test:ErrorRanges" |] (__SOURCE_DIRECTORY__ ++ "../../") "typecheck/constructors/neg_invalid_constructor.fs"
+        """
+        |> compileExeAndRun

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

@@ -4,46 +4,40 @@ namespace FSharp.Compiler.ErrorMessages.ComponentTests
 
 open Xunit
 open FSharp.Test.Utilities
+open FSharp.Test.Utilities.Compiler
 open FSharp.Test.Utilities.Utilities
 open FSharp.Compiler.SourceCodeServices
 
 module ``Confusing Type Name`` =
 
     [<Fact>]
-    let ``Checks expected types with multiple references``() =
-        let csLibAB = """
+    let ``Expected types with multiple references`` () =
+
+        let csLibA =
+            CSharp """
 public class A { }
 public class B<T> { }
-            """
-        let csLibACmpl =
-             CompilationUtil.CreateCSharpCompilation(csLibAB, CSharpLanguageVersion.CSharp8, TargetFramework.NetCoreApp30, name = "libA")
-             |> CompilationReference.Create
+        """ |> withName "libA"
 
-        let csLibBCmpl =
-            CompilationUtil.CreateCSharpCompilation(csLibAB, CSharpLanguageVersion.CSharp8, TargetFramework.NetCoreApp30, name = "libB")
-             |> CompilationReference.Create
+        let csLibB =
+            csLibA |> withName "libB"
 
-        let fsLibC = """
+        let fsLibC =
+            FSharp """
 module AMaker
 let makeA () : A = A()
 let makeB () = B<_>()
-        """
+        """ |> withName "libC" |> withReferences [csLibA]
 
-        let fsLibD = """
+        let fsLibD =
+            FSharp """
 module OtherAMaker
 let makeOtherA () : A = A()
 let makeOtherB () = B<_>()
-        """
-
-        let fsLibCCmpl =
-            Compilation.Create(fsLibC, Fs, Library, cmplRefs = [csLibACmpl], name = "libC")
-            |> CompilationReference.CreateFSharp
+        """ |> withName "libD" |> withReferences [csLibB]
 
-        let fsLibDCmpl =
-            Compilation.Create(fsLibD, Fs, Library, cmplRefs = [csLibBCmpl], name = "libD")
-            |> CompilationReference.CreateFSharp
-
-        let app = """
+        let app =
+            FSharp """
 module ConfusingTypeName
 let a = AMaker.makeA()
 let otherA = OtherAMaker.makeOtherA()
@@ -54,14 +48,15 @@ let b = AMaker.makeB<int>()
 let otherB = OtherAMaker.makeOtherB<int>()
 printfn "%A %A" (b.GetType().AssemblyQualifiedName) (otherB.GetType().AssemblyQualifiedName)
 printfn "%A" (b = otherB)
-        """
-
-        let appCmpl =
-            Compilation.Create(app, Fs, Library, cmplRefs = [csLibACmpl; csLibBCmpl; fsLibCCmpl; fsLibDCmpl])
-
-        CompilerAssert.CompileWithErrors(
-            appCmpl,
-            [|
-             (FSharpErrorSeverity.Error, 1, (6, 19, 6, 25), ("This expression was expected to have type\n    'A (libA, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    \nbut here has type\n    'A (libB, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    "))
-             (FSharpErrorSeverity.Error, 1, (11, 19, 11, 25), ("This expression was expected to have type\n    'B<Microsoft.FSharp.Core.int> (libA, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    \nbut here has type\n    'B<Microsoft.FSharp.Core.int> (libB, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    "))
-             |], true)
+        """ |> withReferences [csLibA; csLibB; fsLibC; fsLibD]
+
+        app
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [
+            (Warning 686, Line 8, Col 9, Line 8, Col 21, "The method or function 'makeB' should not be given explicit type argument(s) because it does not declare its type parameters explicitly")
+            (Warning 686, Line 9, Col 14, Line 9, Col 36, "The method or function 'makeOtherB' should not be given explicit type argument(s) because it does not declare its type parameters explicitly")
+            (Error 1, Line 6, Col 19, Line 6, Col 25, "This expression was expected to have type\n    'A (libA, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    \nbut here has type\n    'A (libB, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    ")
+            (Error 1, Line 11, Col 19, Line 11, Col 25, "This expression was expected to have type\n    'B<Microsoft.FSharp.Core.int> (libA, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    \nbut here has type\n    'B<Microsoft.FSharp.Core.int> (libB, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)'    ")
+
+        ]

tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj

@@ -37,6 +37,10 @@
     <Compile Include="ErrorMessages\WarnExpressionTests.fs" />
     <Compile Include="ErrorMessages\WrongSyntaxInForLoop.fs" />
     <Compile Include="ErrorMessages\ConfusingTypeName.fs" />
+    <Compile Include="Language\CompilerDirectiveTests.fs" />
+    <Compile Include="ConstraintSolver\PrimitiveConstraints.fs" />
+    <Compile Include="ConstraintSolver\MemberConstraints.fs" />
+    <Compile Include="Interop/SimpleInteropTests.fs" />
   </ItemGroup>
 
   <ItemGroup>

tests/FSharp.Compiler.ComponentTests/Interop/SimpleInteropTests.fs

@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.ErrorMessages.ComponentTests
+
+open Xunit
+open FSharp.Test.Utilities
+open FSharp.Test.Utilities.Compiler
+
+module ``C# <-> F# basic interop`` =
+
+    [<Fact>]
+    let ``Instantiate C# type from F#`` () =
+
+        let CSLib =
+            CSharp """
+public class A { }
+      """   |> withName "CSLib"
+
+        let FSLib =
+             FSharp """
+module AMaker
+let makeA () : A = A()
+         """ |> withName "FSLib" |> withReferences [CSLib]
+
+        let app =
+            FSharp """
+module ReferenceCSfromFS
+let a = AMaker.makeA()
+        """ |> withReferences [CSLib; FSLib]
+
+        app
+        |> compile
+        |> shouldSucceed
+
+
+    [<Fact(Skip="TODO: This is broken RN, since netcoreapp30 is used for C# and 3.1 for F#, should be fixed as part of https://github.com/dotnet/fsharp/issues/9740")>]
+    let ``Instantiate F# type from C#`` () =
+        let FSLib =
+            FSharp """
+namespace Interop.FS
+type Bicycle(manufacturer: string) =
+    member this.Manufactirer = manufacturer
+        """ |> withName "FSLib"
+
+        let app =
+            CSharp """
+using Interop.FS;
+public class BicycleShop {
+    public Bicycle[] cycles;
+}
+        """ |> withReferences [FSLib]
+
+        app
+        |> compile
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Instantiate F# type from C# fails without import`` () =
+        let FSLib =
+            FSharp """
+namespace Interop.FS
+type Bicycle(manufacturer: string) =
+    member this.Manufactirer = manufacturer
+        """ |> withName "FSLib"
+
+        let app =
+            CSharp """
+public class BicycleShop {
+    public Bicycle[] cycles;
+}
+        """ |> withReferences [FSLib]
+
+        app
+        |> compile
+        |> shouldFail

tests/FSharp.Compiler.ComponentTests/Language/CompilerDirectiveTests.fs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.Language.ComponentTests
+
+open Xunit
+open FSharp.Test.Utilities
+open FSharp.Test.Utilities.Compiler
+open FSharp.Compiler.SourceCodeServices
+
+module ``Test Compiler Directives`` =
+
+    [<Fact>]
+    let ``r# "" is invalid`` () =
+        Fsx"""
+#r ""
+        """ |> ignoreWarnings
+            |> compile
+            |> shouldSucceed
+            |> withSingleDiagnostic (Warning 213, Line 2, Col 1, Line 2, Col 6, "'' is not a valid assembly name")
+
+    [<Fact>]
+    let ``#r "    " is invalid`` () =
+        Fsx"""
+#r "    "
+        """ |> compile
+            |> shouldFail
+            |> withSingleDiagnostic (Warning 213, Line 2, Col 1, Line 2, Col 10, "'' is not a valid assembly name")

tests/FSharp.Compiler.ComponentTests/testables/typecheck/constructors/neg_invalid_constructor.bsl

@@ -0,0 +1,22 @@
+typecheck/constructors/neg_invalid_constructor.fs (3,29)-(3,56) typecheck error A unique overload for method 'ImmutableStack`1' could not be determined based on type information prior to this program point. A type annotation may be needed.
+
+Known type of argument: 'a list
+
+Candidates:
+ - new : col:'b -> ImmutableStack<'a>
+ - private new : items:'a list -> ImmutableStack<'a>
+typecheck/constructors/neg_invalid_constructor.fs (4,93)-(4,111) typecheck error A unique overload for method 'ImmutableStack`1' could not be determined based on type information prior to this program point. A type annotation may be needed.
+
+Known type of argument: 'a list
+
+Candidates:
+ - new : col:'b -> ImmutableStack<'a>
+ - private new : items:'a list -> ImmutableStack<'a>
+typecheck/constructors/neg_invalid_constructor.fs (7,30)-(7,60) typecheck error A unique overload for method 'ImmutableStack`1' could not be determined based on type information prior to this program point. A type annotation may be needed.
+
+Known type of argument: 'a list
+
+Candidates:
+ - new : col:'b -> ImmutableStack<'a> when 'b :> seq<'c>
+ - private new : items:'a list -> ImmutableStack<'a>
+typecheck/constructors/neg_invalid_constructor.fs (7,30)-(7,60) typecheck error This is not a valid object construction expression. Explicit object constructors must either call an alternate constructor or initialize all fields of the object and specify a call to a super class constructor.

tests/FSharp.Compiler.ComponentTests/testables/typecheck/constructors/neg_invalid_constructor.fs

@@ -0,0 +1,7 @@
+type ImmutableStack<'a> private(items: 'a list) = 
+
+    member this.Push item = ImmutableStack(item::items)
+    member this.Pop = match items with | [] -> failwith "No elements in stack" | x::xs -> x,ImmutableStack(xs)
+
+    // Notice type annotation is commented out, which results in an error
+    new(col (*: seq<'a>*)) = ImmutableStack(List.ofSeq col)