diff --git a/FSharpBuild.Directory.Build.props b/FSharpBuild.Directory.Build.props
index bcdbffa1c12..d06631f786c 100644
--- a/FSharpBuild.Directory.Build.props
+++ b/FSharpBuild.Directory.Build.props
@@ -19,8 +19,8 @@
     <SymStoreDirectory>$(ArtifactsDir)\SymStore</SymStoreDirectory>
     <ProtoOutputPath>$(ArtifactsDir)\Bootstrap</ProtoOutputPath>
     <ValueTupleImplicitPackageVersion>4.4.0</ValueTupleImplicitPackageVersion>
-    <WarningsAsErrors>1182;0025;$(WarningsAsErrors)</WarningsAsErrors>
-    <OtherFlags>$(OtherFlags) --nowarn:3384</OtherFlags>
+    <WarningsAsErrors>0025;$(WarningsAsErrors)</WarningsAsErrors>
+    <OtherFlags>$(OtherFlags) --warnaserror --nowarn:3384</OtherFlags>
   </PropertyGroup>
 
   <!-- nuget -->
diff --git a/src/fsharp/CompilerDiagnostics.fs b/src/fsharp/CompilerDiagnostics.fs
index 2006048da01..a24ea8b7bf8 100644
--- a/src/fsharp/CompilerDiagnostics.fs
+++ b/src/fsharp/CompilerDiagnostics.fs
@@ -372,7 +372,6 @@ let warningOn err level specificWarnOn =
     List.contains n specificWarnOn ||
     // Some specific warnings are never on by default, i.e. unused variable warnings
     match n with
-    | 1182 -> false // chkUnusedValue - off by default
     | 3180 -> false // abImplicitHeapAllocation - off by default
     | 3517 -> false // optFailedToInlineSuggestedValue - off by default
     | _ -> level >= GetWarningLevel err 
diff --git a/src/fsharp/FSharp.Build/CreateFSharpManifestResourceName.fs b/src/fsharp/FSharp.Build/CreateFSharpManifestResourceName.fs
index e4defc092e6..1e981b88503 100644
--- a/src/fsharp/FSharp.Build/CreateFSharpManifestResourceName.fs
+++ b/src/fsharp/FSharp.Build/CreateFSharpManifestResourceName.fs
@@ -19,7 +19,7 @@ type CreateFSharpManifestResourceName public () =
                     (linkFileName:string),
                     (rootNamespace:string), (* may be null *)  
                     (dependentUponFileName:string), (* may be null *) 
-                    (binaryStream:System.IO.Stream) (* may be null *)) : string = 
+                    (_binaryStream:System.IO.Stream) (* may be null *)) : string = 
 
         // The Visual CSharp and XBuild CSharp toolchains transform resource names like this:
         //     SubDir\abc.resx --> SubDir.abc.resources
diff --git a/src/fsharp/FSharp.Build/FSharpEmbedResourceText.fs b/src/fsharp/FSharp.Build/FSharpEmbedResourceText.fs
index 1a8efbe5b66..8757106bc45 100644
--- a/src/fsharp/FSharp.Build/FSharpEmbedResourceText.fs
+++ b/src/fsharp/FSharp.Build/FSharpEmbedResourceText.fs
@@ -356,7 +356,7 @@ open Printf
             printMessage (sprintf "Reading %s" filename)
             let lines = File.ReadAllLines(filename)
                         |> Array.mapi (fun i s -> i,s) // keep line numbers
-                        |> Array.filter (fun (i,s) -> not(s.StartsWith "#"))  // filter out comments
+                        |> Array.filter (fun (_,s) -> not(s.StartsWith "#"))  // filter out comments
 
             printMessage (sprintf "Parsing %s" filename)
             let stringInfos = lines |> Array.map (fun (i,s) -> ParseLine filename i s)
@@ -391,7 +391,7 @@ open Printf
 
             printMessage (sprintf "Generating resource methods for %s" outFilename)
             // gen each resource method
-            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, netFormatString) ->
+            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, _) ->
                 let formalArgs = new System.Text.StringBuilder()
                 let actualArgs = new System.Text.StringBuilder()
                 let mutable firstTime = true
@@ -428,14 +428,14 @@ open Printf
             // gen validation method
             fprintfn out "    /// Call this method once to validate that all known resources are valid; throws if not"
             fprintfn out "    static member RunStartupValidation() ="
-            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, netFormatString) ->
+            stringInfos |> Seq.iter (fun (_, (_,ident), _, _, _) ->
                 fprintfn out "        ignore(GetString(\"%s\"))" ident
             )
             fprintfn out "        ()"  // in case there are 0 strings, we need the generated code to parse
             // gen to resx
             let xd = new System.Xml.XmlDocument()
             xd.LoadXml(xmlBoilerPlateString)
-            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, netFormatString) ->
+            stringInfos |> Seq.iter (fun (_, (_,ident), _, _, netFormatString) ->
                 let xn = xd.CreateElement("data")
                 xn.SetAttribute("name",ident) |> ignore
                 xn.SetAttribute("xml:space","preserve") |> ignore
diff --git a/src/fsharp/FSharp.Build/Fsc.fs b/src/fsharp/FSharp.Build/Fsc.fs
index 42c980a9ce8..39304c25145 100644
--- a/src/fsharp/FSharp.Build/Fsc.fs
+++ b/src/fsharp/FSharp.Build/Fsc.fs
@@ -63,7 +63,6 @@ type public Fsc () as this =
     let mutable tailcalls : bool = true
     let mutable targetProfile : string = null
     let mutable targetType : string = null
-    let mutable toolExe : string = "fsc.exe"
     let defaultToolPath =
         let locationOfThisDll =
             try Some(Path.GetDirectoryName(typeof<Fsc>.Assembly.Location))
@@ -577,7 +576,6 @@ type public Fsc () as this =
             match host with
             | null -> base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
             | _ ->
-                let sources = sources|>Array.map(fun i->i.ItemSpec)
                 let invokeCompiler baseCallDelegate =
                     try
                         let ret =
@@ -590,8 +588,8 @@ type public Fsc () as this =
                     // Do a string compare on the type name to do eliminate a compile time dependency on Microsoft.Build.dll
                     | :? TargetInvocationException as tie when not (isNull tie.InnerException) && (tie.InnerException).GetType().FullName = "Microsoft.Build.Exceptions.BuildAbortedException" ->
                         fsc.Log.LogError(tie.InnerException.Message, [| |])
-                        -1
-                    | e -> reraise()
+                        -1  // ok, this is what happens when VS IDE cancels the build, no need to assert, just log the build-canceled error and return -1 to denote task failed
+                    | _ -> reraise()
 
                 let baseCallDelegate = Func<int>(fun () -> fsc.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) )
                 try
diff --git a/src/fsharp/FSharp.Build/Fsi.fs b/src/fsharp/FSharp.Build/Fsi.fs
index ffe833e0e01..c7b71c7c1d1 100644
--- a/src/fsharp/FSharp.Build/Fsi.fs
+++ b/src/fsharp/FSharp.Build/Fsi.fs
@@ -37,15 +37,12 @@ type public Fsi () as this =
     let mutable provideCommandLineArgs = false
     let mutable references : ITaskItem[] = [||]
     let mutable referencePath : string = null
-    let mutable resources : ITaskItem[] = [||]
     let mutable skipCompilerExecution = false
     let mutable sources : ITaskItem[] = [||]
     let mutable loadSources : ITaskItem[] = [||]
     let mutable useSources : ITaskItem[] = [||]
     let mutable tailcalls : bool = true
     let mutable targetProfile : string = null
-    let mutable targetType : string = null
-    let mutable toolExe : string = "fsi.exe"
     let mutable toolPath : string =
         let locationOfThisDll =
             try Some(Path.GetDirectoryName(typeof<Fsi>.Assembly.Location))
@@ -85,11 +82,6 @@ type public Fsi () as this =
             for item in references do
                 builder.AppendSwitchIfNotNull("-r:", item.ItemSpec)
 
-        let referencePathArray = // create a array of strings
-            match referencePath with
-            | null -> null
-            | _ -> referencePath.Split([|';'; ','|], StringSplitOptions.RemoveEmptyEntries)
-
         // NoWarn
         match disabledWarnings with
         | null -> ()
@@ -293,7 +285,6 @@ type public Fsi () as this =
             match host with
             | null -> base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
             | _ ->
-                let sources = sources|>Array.map(fun i->i.ItemSpec)
                 let invokeCompiler baseCallDelegate =
                     try
                         let ret =
@@ -306,8 +297,8 @@ type public Fsi () as this =
                     // Do a string compare on the type name to do eliminate a compile time dependency on Microsoft.Build.dll
                     | :? TargetInvocationException as tie when not (isNull tie.InnerException) && (tie.InnerException).GetType().FullName = "Microsoft.Build.Exceptions.BuildAbortedException" ->
                         fsi.Log.LogError(tie.InnerException.Message, [| |])
-                        -1
-                    | e -> reraise()
+                        -1  // ok, this is what happens when VS IDE cancels the build, no need to assert, just log the build-canceled error and return -1 to denote task failed
+                    | _ -> reraise()
 
                 let baseCallDelegate = Func<int>(fun () -> fsi.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) )
                 try
diff --git a/src/fsharp/FSharp.Build/MapSourceRoots.fs b/src/fsharp/FSharp.Build/MapSourceRoots.fs
index 84310352b8d..2d1b671bf54 100644
--- a/src/fsharp/FSharp.Build/MapSourceRoots.fs
+++ b/src/fsharp/FSharp.Build/MapSourceRoots.fs
@@ -122,7 +122,7 @@ type MapSourceRoots () =
 
                     for root in mappedSourceRoots do
                         match root.GetMetadata SourceControl with
-                        | HasValue v when isSourceControlled -> mapNestedRootIfEmpty root
+                        | HasValue _ when isSourceControlled -> mapNestedRootIfEmpty root
                         | NullOrEmpty when not isSourceControlled -> mapNestedRootIfEmpty root
                         | _ -> ()
 
diff --git a/src/fsharp/FSharp.Compiler.Server.Shared/FSharpInteractiveServer.fs b/src/fsharp/FSharp.Compiler.Server.Shared/FSharpInteractiveServer.fs
index eca486f48cc..bc13218a5d8 100644
--- a/src/fsharp/FSharp.Compiler.Server.Shared/FSharpInteractiveServer.fs
+++ b/src/fsharp/FSharp.Compiler.Server.Shared/FSharpInteractiveServer.fs
@@ -37,7 +37,7 @@ type internal FSharpInteractiveServer() =
         LifetimeServices.RenewOnCallTime      <- TimeSpan(7,0,0,0);
         LifetimeServices.SponsorshipTimeout   <- TimeSpan(7,0,0,0);
         ChannelServices.RegisterChannel(chan,false);
-        let objRef = RemotingServices.Marshal(server,"FSIServer") 
+        RemotingServices.Marshal(server,"FSIServer") |> ignore
         ()
 
     static member StartClient(channelName) =
diff --git a/tests/FSharp.Build.UnitTests/FSharp.Build.UnitTests.fsproj b/tests/FSharp.Build.UnitTests/FSharp.Build.UnitTests.fsproj
index 2572d28cc62..69c05f34b17 100644
--- a/tests/FSharp.Build.UnitTests/FSharp.Build.UnitTests.fsproj
+++ b/tests/FSharp.Build.UnitTests/FSharp.Build.UnitTests.fsproj
@@ -8,6 +8,7 @@
     <OutputType>Library</OutputType>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UnitTestType>nunit</UnitTestType>
+    <NoWarn>$(NoWarn);1182</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs
index 439b0bd7bdb..9800bb3512c 100644
--- a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs
+++ b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/UnsupportedAttributes.fs
@@ -20,6 +20,7 @@ type C() =
     member _.G() = ()
         """
         |> FSharp
+        |> withOptions ["--nowarn:1182"]
         |> typecheck
         |> shouldFail
         |> withResults [
diff --git a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/WarnExpressionTests.fs b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/WarnExpressionTests.fs
index 3e7768efb94..18f4c19fb1c 100644
--- a/tests/FSharp.Compiler.ComponentTests/ErrorMessages/WarnExpressionTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/ErrorMessages/WarnExpressionTests.fs
@@ -70,7 +70,7 @@ let changeProperty() =
     [<Fact>]
     let ``Don't Warn If Property Without Setter``() =
         FSharp """
-type MyClass(property1 : int) =
+type MyClass(_property1 : int) =
     member val Property2 = "" with get
 
 let x = MyClass(1)
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs
index 5749edc7ef8..0e2822484c9 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs
@@ -4,9 +4,9 @@
 
 type R =
     { x: int }
-    member this.Equals(s:char) = true
+    member this.Equals(_:char) = true
     // member this.Equals(s:R) = 1.
-    member this.Equals(?s:char) = true
+    member this.Equals(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs
index 25aa07cd456..dddc506aa4f 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs
@@ -3,9 +3,9 @@
 // Overloading of GetHashCode()
 type R =
     { x: int }
-    member this.GetHashCode(s:char) =  1
+    member this.GetHashCode(_s:char) =  1
     //member this.GetHashCode() = 1.
-    member this.GetHashCode(?s:char) = 1 
+    member this.GetHashCode(?_s:char) = 1 
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs
index 2e651f776dd..cb3c47a39ac 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs
@@ -4,9 +4,9 @@
 
 type R =
     { x: int }
-    member this.ToString(s:char) = true
+    member this.ToString(_s:char) = true
     member this.ToString() =       true
-    member this.ToString(?s:char) = true
+    member this.ToString(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs
index 0e289605e5a..7eab984dc44 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs
@@ -3,9 +3,9 @@
 // Overloading of Equals()
 
 type DU = | A
-          member this.Equals(s:char) = true
+          member this.Equals(_s:char) = true
           //member this.Equals(s:DU) = 1.
-          member this.Equals(?s:char) = true
+          member this.Equals(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs
index f85e1c1dbd1..8e4d6dba20a 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs
@@ -3,9 +3,9 @@
 // Overloading of GetHashCode()
 
 type DU = | A
-            member this.GetHashCode(s:char) =  1
+            member this.GetHashCode(_s:char) =  1
             //member this.GetHashCode() = 1.
-            member this.GetHashCode(?s:char) = 1 
+            member this.GetHashCode(?_s:char) = 1 
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_ToString.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_ToString.fs
index 64400c453da..2e4b6e8d6d8 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_ToString.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_ToString.fs
@@ -3,9 +3,9 @@
 // Overloading of ToString()
 
 type DU = | A
-          member this.ToString(s:char) = true
+          member this.ToString(_s:char) = true
           member this.ToString() =       true
-          member this.ToString(?s:char) = true
+          member this.ToString(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift001.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift001.fs
index 251673d2e07..acea144b3cd 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift001.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift001.fs
@@ -9,4 +9,4 @@
 type ID<'T> =
     static member id (x:'T) = x
 
-let f x = ID<ID<int>>.id  (* ok *)
+let f _x = ID<ID<int>>.id  (* ok *)
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift002.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift002.fs
index ec1187fbd79..a3333984cb3 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift002.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalAnalysis/Shift/Generics/RightShift002.fs
@@ -9,4 +9,4 @@
 type ID<'T> =
     static member id (x:'T) = x
 
-let f x = ID<ID<int>> .id  (* ok *)
+let f _x = ID<ID<int>> .id  (* ok *)
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalFiltering/HashLight/IndentationWithComputationExpression01.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalFiltering/HashLight/IndentationWithComputationExpression01.fs
index 5121084b063..c4e4117e82c 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalFiltering/HashLight/IndentationWithComputationExpression01.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/LexicalFiltering/HashLight/IndentationWithComputationExpression01.fs
@@ -10,7 +10,7 @@ async {
                     return 5 
                 }
               )
-    let! b = a
-    for i in 1..10000 do
+    let! _b = a
+    for _ in 1..10000 do
         ()
 } |> Async.RunSynchronously
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_Equals.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_Equals.fs
index 398f407add6..3e38632656f 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_Equals.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_Equals.fs
@@ -4,9 +4,9 @@
 
 [<Struct>]
 type S3 =
-    member this.Equals(s:char) = true
+    member this.Equals(_s:char) = true
     //member this.Equals(s:S3) = 1.
-    member this.Equals(?s:char) = true
+    member this.Equals(?_s:char) = true
 
 #if INTERACTIVE
 ;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_GetHashCode.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_GetHashCode.fs
index aca1cc87f7b..8ef04689c68 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_GetHashCode.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_GetHashCode.fs
@@ -4,9 +4,9 @@
 
 [<Struct>]
 type S2 =
-    member this.GetHashCode(s:char) =  1
+    member this.GetHashCode(_s:char) =  1
     //member this.GetHashCode() = 1.
-    member this.GetHashCode(?s:char) = 1 
+    member this.GetHashCode(?_s:char) = 1 
 
 #if INTERACTIVE
 ;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs
index 8a5ad46511f..af2c64e3c6c 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs
@@ -4,9 +4,9 @@
 
 [<Struct>]
 type S1 =
-    member this.ToString(s:char) = true
+    member this.ToString(_s:char) = true
     member this.ToString() =       true
-    member this.ToString(?s:char) = true
+    member this.ToString(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/Basic/Stats.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/Basic/Stats.fs
index 8bdb04c9dc1..7158a8f5a04 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/Basic/Stats.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/Basic/Stats.fs
@@ -18,7 +18,7 @@ let variance xs = let m = mean xs in meanMap (fun x -> sqr (x-m)) xs
 let sdeviation xs = sqrt (variance xs)
 
 let skewness xs = 
-  let n = float (List.length xs)
+  let _n = float (List.length xs)
   let m = mean xs
   let s = sdeviation xs
   meanMap (fun x -> cube(x-m)) xs / (cube s)
diff --git a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/TypeChecker/GenericSubType01.fs b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/TypeChecker/GenericSubType01.fs
index b6a3b29de86..3f7042a9d17 100644
--- a/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/TypeChecker/GenericSubType01.fs
+++ b/tests/FSharp.Compiler.ComponentTests/resources/tests/Conformance/UnitsOfMeasure/TypeChecker/GenericSubType01.fs
@@ -5,7 +5,7 @@
 
 type SC< [<Measure>] 'u>() = class end
 type TC< [<Measure>] 'u>() = inherit SC<'u>()
-let wff (x:SC<'u>) = ()
+let wff (_x:SC<'u>) = ()
 
 
 let wgg (x:TC<'v>) = wff x      // OK
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj
index d30dd32729c..b8b9c5df2b7 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj
@@ -8,6 +8,7 @@
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UnitTestType>xunit</UnitTestType>
     <ExcludeFromSourceBuild>true</ExcludeFromSourceBuild>
+    <NoWarn>$(NoWarn);1182</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs
index 431ac983ec4..864ffbfee8d 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs
@@ -418,7 +418,7 @@ let y = 2
             foundInner <- foundInner || name = "inner")
         let code = @"
 let x =
-    let inner = 1
+    let _inner = 1
     ()
 "
         script.Eval(code) |> ignoreValue
diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
index 3ad6dd6550f..f7eee1e9071 100644
--- a/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
+++ b/tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
@@ -4,7 +4,7 @@
     <OutputType>Exe</OutputType>
     <TargetFrameworks Condition="'$(OS)' != 'Unix'">net472;net5.0</TargetFrameworks>
     <TargetFrameworks Condition="'$(OS)' == 'Unix'">net5.0</TargetFrameworks>
-    <NoWarn>$(NoWarn);44;75;</NoWarn>
+    <NoWarn>$(NoWarn);44;75;1182;</NoWarn>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GenerateProgramFile>false</GenerateProgramFile>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
diff --git a/tests/FSharp.Compiler.UnitTests/FSharp.Compiler.UnitTests.fsproj b/tests/FSharp.Compiler.UnitTests/FSharp.Compiler.UnitTests.fsproj
index dda54a28a49..81feb309b67 100644
--- a/tests/FSharp.Compiler.UnitTests/FSharp.Compiler.UnitTests.fsproj
+++ b/tests/FSharp.Compiler.UnitTests/FSharp.Compiler.UnitTests.fsproj
@@ -9,7 +9,7 @@
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <DefineConstants>$(DefineConstants);ASSUME_PREVIEW_FSHARP_CORE</DefineConstants>
     <UnitTestType>xunit</UnitTestType>
-    <NoWarn>$(NoWarn);57;3186;1104</NoWarn>
+    <NoWarn>$(NoWarn);57;3186;1104;1182;</NoWarn>
   </PropertyGroup>
 
     <ItemGroup>
diff --git a/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj b/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
index aa39265d2a0..0a78b26ed16 100644
--- a/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
+++ b/tests/FSharp.Core.UnitTests/FSharp.Core.UnitTests.fsproj
@@ -6,6 +6,7 @@
     <TargetFrameworks>net5.0;net472</TargetFrameworks>
     <TargetFrameworks Condition="'$(OS)' == 'Unix'">net5.0</TargetFrameworks>
     <OutputType>Library</OutputType>
+    <NoWarn>$(NoWarn);1182</NoWarn>
 
     <AssemblyName>FSharp.Core.UnitTests</AssemblyName>
     <PackageId>Microsoft.FSharp.Core.UnitTests</PackageId>
diff --git a/tests/benchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj b/tests/benchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj
index 68b175fc21a..18f6ace7f7b 100644
--- a/tests/benchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj
+++ b/tests/benchmarks/CompilerServiceBenchmarks/FSharp.Compiler.Benchmarks.fsproj
@@ -4,6 +4,7 @@
     <OutputType>Exe</OutputType>
     <TargetFramework>net5.0</TargetFramework>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
+    <NoWarn>$(NoWarn);1182</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/benchmarks/MicroPerf/MicroPerf.fsproj b/tests/benchmarks/MicroPerf/MicroPerf.fsproj
index 6e9e411e438..7fa08e87e65 100644
--- a/tests/benchmarks/MicroPerf/MicroPerf.fsproj
+++ b/tests/benchmarks/MicroPerf/MicroPerf.fsproj
@@ -11,6 +11,8 @@
     <OtherFlags>$(OtherFlags) --langversion:preview</OtherFlags>
     <OtherFlags>$(OtherFlags) --define:PREVIEW</OtherFlags>
 
+    <NoWarn>$(NoWarn);1182</NoWarn>
+
     <!-- By default this project will compile with the proto compiler -->
     <!-- Uncommenting this will build with a previous installed compiler  -->
     <!--
diff --git a/tests/benchmarks/TaskPerf/TaskPerf.fsproj b/tests/benchmarks/TaskPerf/TaskPerf.fsproj
index 88e9af5c263..0bda8ebc77c 100644
--- a/tests/benchmarks/TaskPerf/TaskPerf.fsproj
+++ b/tests/benchmarks/TaskPerf/TaskPerf.fsproj
@@ -13,6 +13,9 @@
 	<OtherFlags>$(OtherFlags) --nowarn:3511 --nowarn:3513</OtherFlags>
 	<OtherFlags>$(OtherFlags) --langversion:preview</OtherFlags>
 	<OtherFlags>$(OtherFlags) --define:PREVIEW</OtherFlags>
+
+	<NoWarn>$(NoWarn);1182</NoWarn>
+
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/fsharp/Compiler/Language/ByrefTests.fs b/tests/fsharp/Compiler/Language/ByrefTests.fs
index 2bb9709a86f..14ddbd9b6dc 100644
--- a/tests/fsharp/Compiler/Language/ByrefTests.fs
+++ b/tests/fsharp/Compiler/Language/ByrefTests.fs
@@ -248,7 +248,7 @@ type MyClass() =
 
 let test () =
     let mutable x = 1
-    let y = &&x
+    let _y = &&x
     ()
             """
 
@@ -280,12 +280,12 @@ type C() =
         let verifyProperty = """.property instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute)
                 X()
         {
-          .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 ) 
+          .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 )
           .get instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute) Test/C::get_X()
         }"""
 
-        let verifyMethod = """.method public hidebysig specialname 
-                instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute) 
+        let verifyMethod = """.method public hidebysig specialname
+                instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute)
                 get_X() cil managed
         {
           .param [0]
@@ -307,7 +307,7 @@ type C<'T>() =
     member _.X<'U>(): inref<'T> = &x
             """
 
-        let verifyMethod = """.method public hidebysig instance !T& modreq([runtime]System.Runtime.InteropServices.InAttribute) 
+        let verifyMethod = """.method public hidebysig instance !T& modreq([runtime]System.Runtime.InteropServices.InAttribute)
                 X<U>() cil managed
         {
           .param [0]
@@ -329,8 +329,8 @@ type C<'T>() =
     abstract X<'U> : unit -> inref<'U>
             """
 
-        let verifyMethod = """.method public hidebysig abstract virtual 
-                instance !!U& modreq([runtime]System.Runtime.InteropServices.InAttribute) 
+        let verifyMethod = """.method public hidebysig abstract virtual
+                instance !!U& modreq([runtime]System.Runtime.InteropServices.InAttribute)
                 X<U>() cil managed
         {
           .param [0]
@@ -348,18 +348,18 @@ type C<'T>() =
 module Test
 
 type C =
-    abstract X: inref<int> 
+    abstract X: inref<int>
             """
 
         let verifyProperty = """.property instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute)
                 X()
         {
-          .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 ) 
+          .custom instance void [runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 )
           .get instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute) Test/C::get_X()
         }"""
 
         let verifyMethod = """.method public hidebysig specialname abstract virtual
-                instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute) 
+                instance int32& modreq([runtime]System.Runtime.InteropServices.InAttribute)
                 get_X() cil managed
         {
           .param [0]
diff --git a/tests/fsharp/Compiler/Language/StructActivePatternTests.fs b/tests/fsharp/Compiler/Language/StructActivePatternTests.fs
index 6107d368ef9..bfff68e5b4e 100644
--- a/tests/fsharp/Compiler/Language/StructActivePatternTests.fs
+++ b/tests/fsharp/Compiler/Language/StructActivePatternTests.fs
@@ -19,18 +19,18 @@ let fail msg =
 
     [<Test>]
     let ``Partial active pattern returns Option`1`` () =
-        pass "let (|Foo|_|) x = None"
+        pass "let (|Foo|_|) _x = None"
 
     [<Test>]
     let ``Partial struct active pattern returns ValueOption`1`` () =
-        pass "[<return:Struct>] let (|P1|_|) x = ValueNone"
+        pass "[<return:Struct>] let (|P1|_|) _x = ValueNone"
 
     [<Test>]
     let ``StructAttribute can be placed at the active pattern return type annotation`` () =
         pass
             """
-let (|P1|_|) x: [<Struct>] _ = ValueNone
-let (|P2|_|) x: [<return:Struct>] _ = ValueNone
+let (|P1|_|) _x: [<Struct>] _ = ValueNone
+let (|P2|_|) _x: [<return:Struct>] _ = ValueNone
             """
 
     [<Test>]
@@ -38,7 +38,7 @@ let (|P2|_|) x: [<return:Struct>] _ = ValueNone
         run """
 [<Struct>]
 type T1 = { v1: int }
-and T2 = 
+and T2 =
   | T2C1 of int * string
   | T2C2 of T1 * T2
 and [<Struct>] T3 = { v3: T2 }
@@ -46,25 +46,25 @@ and T4() =
     let mutable _v4 = { v3 = T2C2({v1=0}, T2C1(1, "hey")) }
     member __.v4 with get() = _v4 and set (x) = _v4 <- x
 
-[<return:Struct>] 
+[<return:Struct>]
 let (|P1|_|) =
     function
     | 0 -> ValueNone
     | _ -> ValueSome()
 
-[<return:Struct>] 
+[<return:Struct>]
 let (|P2|_|) =
     function
     | "foo" -> ValueNone
     | _ -> ValueSome "bar"
 
-[<return:Struct>] 
+[<return:Struct>]
 let (|P3|_|) (x: T2) =
   match x with
   | T2C1(a, b) -> ValueSome(a, b)
   | _ -> ValueNone
 
-[<return:Struct>] 
+[<return:Struct>]
 let (|P4|_|) (x: T4) =
   match x.v4 with
   | { v3 = T2C2 ({v1=a}, P3(b, c)) } -> ValueSome (a, b, c)
@@ -87,7 +87,7 @@ match t4 with
             """
 
     [<Test>]
-    let ``[<return:>] attribute is rotated to the return value``() = 
+    let ``[<return:>] attribute is rotated to the return value``() =
         run
             """
 open System
@@ -96,7 +96,7 @@ open System
 type MyAttribute() =
     inherit Attribute()
 
-let extract xs = 
+let extract xs =
   xs
   |> Seq.map (fun x -> x.GetType().Name)
   |> List.ofSeq
@@ -121,7 +121,7 @@ match ret_attrs, binding_attrs with
 | _ -> fail $"ret_attrs = {ret_attrs}, binding_attrs = {binding_attrs} method = {method}"
             """
     [<Test>]
-    let ``Implicitly-targeted attribute on let binding do not target return``() = 
+    let ``Implicitly-targeted attribute on let binding do not target return``() =
         run
             """
 open System
@@ -130,7 +130,7 @@ open System
 type MyAttribute() =
     inherit Attribute()
 
-let extract xs = 
+let extract xs =
   xs
   |> Seq.map (fun x -> x.GetType().Name)
   |> List.ofSeq
@@ -170,7 +170,7 @@ let (|Foo|_|) x = ValueNone
 
     [<Test>]
     let ``StructAttribute must explicitly target active pattern return value`` () =
-        fail 
+        fail
             """
 [<Struct>]
 let (|Foo|_|) x = ValueNone
@@ -179,15 +179,15 @@ let (|Foo|_|) x = ValueNone
                "This attribute is not valid for use on this language element");
               (FSharpDiagnosticSeverity.Error, 1, (2, 1, 3, 16),
                "This expression was expected to have type
-    ''a option'    
+    ''a option'
 but here has type
     ''b voption'    ")|]
 
     [<Test>]
     let ``StructAttribute not allowed on other bindings than partial active pattern definitions`` () =
-        fail 
+        fail
             """
-[<return:Struct>] 
+[<return:Struct>]
 let x = 1
 
 [<return:Struct>]
diff --git a/tests/fsharp/Compiler/Regressions/NullableOptionalRegressionTests.fs b/tests/fsharp/Compiler/Regressions/NullableOptionalRegressionTests.fs
index c4009ee5233..8e8b96db39e 100644
--- a/tests/fsharp/Compiler/Regressions/NullableOptionalRegressionTests.fs
+++ b/tests/fsharp/Compiler/Regressions/NullableOptionalRegressionTests.fs
@@ -26,7 +26,7 @@ type Node (child:Node)=
 let test () =
     let parent = Node()
     let b1 = OverloadMeths.Map(parent.child, fun x -> x.child)
-    let c1 = OverloadMeths.Map(b1, fun x -> x.child)
+    let _c1 = OverloadMeths.Map(b1, fun x -> x.child)
     ()
         """
         |> withLangVersion50
diff --git a/tests/fsharp/Compiler/Warnings/AssignmentWarningTests.fs b/tests/fsharp/Compiler/Warnings/AssignmentWarningTests.fs
index d6ef26bcdf1..68354fae739 100644
--- a/tests/fsharp/Compiler/Warnings/AssignmentWarningTests.fs
+++ b/tests/fsharp/Compiler/Warnings/AssignmentWarningTests.fs
@@ -66,7 +66,7 @@ let changeProperty() =
 type MyClass(property1 : int) =
     member val Property1 = property1
     member val Property2 = "" with get, set
-    
+
 let x = MyClass(1)
 let y = "hello"
 
@@ -83,9 +83,9 @@ let changeProperty() =
     let ``Don't warn if assignment to property without setter ``() =
         CompilerAssert.TypeCheckSingleError
             """
-type MyClass(property1 : int) =
+type MyClass(_property1 : int) =
     member val Property2 = "" with get
-    
+
 let x = MyClass(1)
 let y = "hello"
 
diff --git a/tests/fsharp/FSharpSuite.Tests.fsproj b/tests/fsharp/FSharpSuite.Tests.fsproj
index 79fdc521ea7..e082c78b253 100644
--- a/tests/fsharp/FSharpSuite.Tests.fsproj
+++ b/tests/fsharp/FSharpSuite.Tests.fsproj
@@ -13,7 +13,7 @@
     <Tailcalls>false</Tailcalls>
     <OtherFlags>$(OtherFlags) --warnon:1182 --langversion:preview</OtherFlags>
     <UnitTestType>nunit</UnitTestType>
-    <NoWarn>3186</NoWarn>
+    <NoWarn>$(NoWarn);3186</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/fsharp/single-test.fs b/tests/fsharp/single-test.fs
index 7c9d7aae2c8..947eba4064f 100644
--- a/tests/fsharp/single-test.fs
+++ b/tests/fsharp/single-test.fs
@@ -146,6 +146,7 @@ let generateProjectArtifacts (pc:ProjectConfiguration) outputType (targetFramewo
     <DebugType>portable</DebugType>
     <LangVersion>$(LANGUAGEVERSION)</LangVersion>
     <Optimize>$(OPTIMIZE)</Optimize>
+    <NoWarn>$(NOWARN);1182;</NoWarn>
     <SignAssembly>false</SignAssembly>
     <DefineConstants Condition=""'$(OutputType)' == 'Script' and '$(FSharpTestCompilerVersion)' == 'coreclr'"">NETCOREAPP</DefineConstants>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
@@ -354,8 +355,8 @@ let singleTestBuildAndRunCore cfg copyFiles p languageVersion =
 
         let sources = extraSources |> List.filter (fileExists cfg)
 
-        fsc cfg "%s --optimize -a -o:test--optimize-lib.dll -g --langversion:preview " cfg.fsc_flags sources
-        fsc cfg "%s --optimize -r:test--optimize-lib.dll -o:test--optimize-client-of-lib.exe -g --langversion:preview " cfg.fsc_flags sources
+        fsc cfg "%s --optimize -a -o:test--optimize-lib.dll -g --langversion:preview --nowarn:1182 " cfg.fsc_flags sources
+        fsc cfg "%s --optimize -r:test--optimize-lib.dll -o:test--optimize-client-of-lib.exe -g --langversion:preview --nowarn:1182 " cfg.fsc_flags sources
 
         peverify cfg "test--optimize-lib.dll"
         peverify cfg "test--optimize-client-of-lib.exe"
@@ -428,11 +429,11 @@ let singleVersionedNegTest (cfg: TestConfig) version testname =
         if cfg.fsc_flags.Contains("--warnaserror-") then String.Empty
         else "--warnaserror"
 
-    fscAppendErrExpectFail cfg  (sprintf "%s.err" testname) """%s --vserrors %s --nologo --maxerrors:10000 -a -o:%s.dll""" cfg.fsc_flags warnaserror testname sources
+    fscAppendErrExpectFail cfg  (sprintf "%s.err" testname) """%s --vserrors %s --nologo --nowarn:1182 --maxerrors:10000 -a -o:%s.dll""" cfg.fsc_flags warnaserror testname sources
 
     let diff = fsdiff cfg (sprintf "%s.err" testname) (sprintf "%s.bsl" testname)
 
-    fscAppendErrExpectFail cfg (sprintf "%s.vserr" testname) "%s --test:ContinueAfterParseFailure --vserrors %s --nologo --maxerrors:10000 -a -o:%s.dll" cfg.fsc_flags warnaserror testname sources
+    fscAppendErrExpectFail cfg (sprintf "%s.vserr" testname) "%s --test:ContinueAfterParseFailure --vserrors %s --nologo --nowarn:1182 --maxerrors:10000 -a -o:%s.dll" cfg.fsc_flags warnaserror testname sources
 
     let vbslDiff = fsdiff cfg (sprintf "%s.vserr" testname) VSBSLFILE
 
diff --git a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs
index 5749edc7ef8..6b8188e7cf0 100644
--- a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs
+++ b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_Equals.fs
@@ -4,9 +4,9 @@
 
 type R =
     { x: int }
-    member this.Equals(s:char) = true
+    member this.Equals(_s:char) = true
     // member this.Equals(s:R) = 1.
-    member this.Equals(?s:char) = true
+    member this.Equals(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs
index 25aa07cd456..dddc506aa4f 100644
--- a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs
+++ b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_GetHashCode.fs
@@ -3,9 +3,9 @@
 // Overloading of GetHashCode()
 type R =
     { x: int }
-    member this.GetHashCode(s:char) =  1
+    member this.GetHashCode(_s:char) =  1
     //member this.GetHashCode() = 1.
-    member this.GetHashCode(?s:char) = 1 
+    member this.GetHashCode(?_s:char) = 1 
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs
index 2e651f776dd..cb3c47a39ac 100644
--- a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs
+++ b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/RecordTypes/Overload_ToString.fs
@@ -4,9 +4,9 @@
 
 type R =
     { x: int }
-    member this.ToString(s:char) = true
+    member this.ToString(_s:char) = true
     member this.ToString() =       true
-    member this.ToString(?s:char) = true
+    member this.ToString(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs
index 0e289605e5a..7eab984dc44 100644
--- a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs
+++ b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_Equals.fs
@@ -3,9 +3,9 @@
 // Overloading of Equals()
 
 type DU = | A
-          member this.Equals(s:char) = true
+          member this.Equals(_s:char) = true
           //member this.Equals(s:DU) = 1.
-          member this.Equals(?s:char) = true
+          member this.Equals(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs
index f85e1c1dbd1..8e4d6dba20a 100644
--- a/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs
+++ b/tests/fsharpqa/Source/Conformance/BasicTypeAndModuleDefinitions/UnionTypes/Overload_GetHashCode.fs
@@ -3,9 +3,9 @@
 // Overloading of GetHashCode()
 
 type DU = | A
-            member this.GetHashCode(s:char) =  1
+            member this.GetHashCode(_s:char) =  1
             //member this.GetHashCode() = 1.
-            member this.GetHashCode(?s:char) = 1 
+            member this.GetHashCode(?_s:char) = 1 
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/fsharpqa/Source/Conformance/DeclarationElements/AccessibilityAnnotations/basic/InternalizedIFaces02.fs b/tests/fsharpqa/Source/Conformance/DeclarationElements/AccessibilityAnnotations/basic/InternalizedIFaces02.fs
index c3959b59f7c..ea85e8eb5fc 100644
--- a/tests/fsharpqa/Source/Conformance/DeclarationElements/AccessibilityAnnotations/basic/InternalizedIFaces02.fs
+++ b/tests/fsharpqa/Source/Conformance/DeclarationElements/AccessibilityAnnotations/basic/InternalizedIFaces02.fs
@@ -12,6 +12,6 @@ module N.M
 
  and Gen<'a> = 
   | Gen of (int -> StdGen -> 'a) 
-  member x.Map f = failwith ""
+  member x.Map _f = failwith ""
   interface IGen with
     member x.AsGenObject = x.Map box
diff --git a/tests/fsharpqa/Source/Conformance/DeclarationElements/CustomAttributes/Basic/InExternDecl.fs b/tests/fsharpqa/Source/Conformance/DeclarationElements/CustomAttributes/Basic/InExternDecl.fs
index 10bc1a73ad1..f2ed3e4a277 100644
--- a/tests/fsharpqa/Source/Conformance/DeclarationElements/CustomAttributes/Basic/InExternDecl.fs
+++ b/tests/fsharpqa/Source/Conformance/DeclarationElements/CustomAttributes/Basic/InExternDecl.fs
@@ -5,4 +5,4 @@
 module M
 
 type myAttrib() = inherit System.Attribute()
-extern int A([<myAttrib>] int a)
+extern int A([<myAttrib>] int _a)
diff --git a/tests/fsharpqa/Source/Conformance/DeclarationElements/MemberDefinitions/OverloadingMembers/NoWarningWhenDoingDispatchSlotInference01.fs b/tests/fsharpqa/Source/Conformance/DeclarationElements/MemberDefinitions/OverloadingMembers/NoWarningWhenDoingDispatchSlotInference01.fs
index 5dbadd0b1c5..f09fdd3bad3 100644
--- a/tests/fsharpqa/Source/Conformance/DeclarationElements/MemberDefinitions/OverloadingMembers/NoWarningWhenDoingDispatchSlotInference01.fs
+++ b/tests/fsharpqa/Source/Conformance/DeclarationElements/MemberDefinitions/OverloadingMembers/NoWarningWhenDoingDispatchSlotInference01.fs
@@ -5,9 +5,9 @@
 
 type MyTraceListener = class
                         inherit System.Diagnostics.TraceListener
-                        override x.Write (message:string) = ()
-                        override x.WriteLine (message:string) = ()
-                        override x.Fail (message:string) = exit 0
+                        override x.Write (_message:string) = ()
+                        override x.WriteLine (_message:string) = ()
+                        override x.Fail (_message:string) = exit 0
                        end
 
 exit 0
diff --git a/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint.fs b/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint.fs
index f66aeb7c56e..00f08806dda 100644
--- a/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint.fs
+++ b/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint.fs
@@ -10,6 +10,6 @@ open System.Numerics                    // <- we need this since the deprecated
 
 let v1 = 99999999I                      // bigint          (System.Numerics.BigInteger)
 
-let check(x:BigInteger) = true
+let check(_x:BigInteger) = true
 
 exit (if check(v1) then 0 else 1)
diff --git a/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint02.fs b/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint02.fs
index 1b2b4df8dea..3ffb3420bd2 100644
--- a/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint02.fs
+++ b/tests/fsharpqa/Source/Conformance/Expressions/ConstantExpressions/bigint02.fs
@@ -9,7 +9,7 @@
 
 let v1 = 99999999I      // bigint          (Microsoft.FSharp.Core.bigint)
 
-let check(x:bigint) = true
+let check(_x:bigint) = true
 
 if check(v1) = false then exit 1
 
diff --git a/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/QueryExpressions/UppercaseIdentifier04.fs b/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/QueryExpressions/UppercaseIdentifier04.fs
index de1f4a7ecdc..e2451f56d77 100644
Binary files a/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/QueryExpressions/UppercaseIdentifier04.fs and b/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/QueryExpressions/UppercaseIdentifier04.fs differ
diff --git a/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/SequenceExpressions/final_yield_dash_gt_01.fs b/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/SequenceExpressions/final_yield_dash_gt_01.fs
index 537141f6eae..41162b52161 100644
--- a/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/SequenceExpressions/final_yield_dash_gt_01.fs
+++ b/tests/fsharpqa/Source/Conformance/Expressions/DataExpressions/SequenceExpressions/final_yield_dash_gt_01.fs
@@ -6,5 +6,5 @@
 //<Expects status="success"></Expects>
 #light
 
-let s1 = seq { for i in [ 1 .. 2 ] -> 10 }
+let s1 = seq { for _i in [ 1 .. 2 ] -> 10 }
 (if (Seq.head s1) = 10 then 0 else 1) |> exit
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/AdHoc.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/AdHoc.fs
index 19d6d8d2a2d..21744ae6bde 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/AdHoc.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/AdHoc.fs
@@ -5,6 +5,9 @@
 // Notice that the [<OverloadID("...")>] attribute is no longer needed
 // These different return types are used to determine which overload got chosen
 namespace N
+
+#nowarn "1182"
+
 type One = | One
 type Two = | Two
 type Three = | Three
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03.fs
index 983a5d0eab1..19f3303b338 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03rec.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03rec.fs
index 8e531e6e9d4..1607e683cef 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03rec.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/OneTypeVariable03rec.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest01.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest01.fs
index 932582bb26c..cbc44aa259a 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest01.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest01.fs
@@ -2,6 +2,9 @@
 // Regression test for FSHARP1.0:4758
 // Type Inference
 namespace N
+
+#nowarn "1182"
+
 module ActualTests1 = 
     type Var<'a> =
         static member Foo(x:Var<'a>,y:'a)      = failwith "" : Var<bool>
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest02.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest02.fs
index ccb5255099a..75adafdb0d4 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest02.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/RegressionTest02.fs
@@ -2,6 +2,9 @@
 // Regression test for FSHARP1.0:4758
 // Type Inference
 namespace N
+
+#nowarn "1182"
+
 module ActualTests2 = 
 
     type Var<'a> =
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01.fs
index 401f439a41d..4f8153b6e1b 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01rec.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01rec.fs
index 2b2193b09bc..bab9ab53972 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01rec.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariables01rec.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00.fs
index 790b885d766..22676ea0c83 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00rec.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00rec.fs
index 157074da583..d89157fcbf2 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00rec.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoDifferentTypeVariablesGen00rec.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02.fs
index 7cd8d6398e5..34861de16a0 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02rec.fs b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02rec.fs
index b7bf6a248ee..867e5322f10 100644
--- a/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02rec.fs
+++ b/tests/fsharpqa/Source/Conformance/InferenceProcedures/TypeInference/TwoEqualTypeVariables02rec.fs
@@ -3,6 +3,9 @@
 // Type Inference
 // Check Method Disambiguation When User Generic Variable Get Instantiated By Overload Resolution
 namespace N
+
+#nowarn "1182"
+
 // These different return types are used to determine which overload got chosen
 type One = | One
 type Two = | Two
diff --git a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fs b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fs
index 726f2b8658b..3f0f235d45f 100644
--- a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fs
+++ b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fs
@@ -1,7 +1,7 @@
 // #Regression #Conformance #LexicalAnalysis #ReqNOMT 
 // Regression test for FSHARP1.0:6044
 
-#nowarn "44" "49"
+#nowarn "44" "49" "1182"
 
 [<System.Obsolete("Dummy attribute to trigger a warning")>]
 let obsoleteIdentifier = 12
diff --git a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fsx b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fsx
index 726f2b8658b..3f0f235d45f 100644
--- a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fsx
+++ b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn01.fsx
@@ -1,7 +1,7 @@
 // #Regression #Conformance #LexicalAnalysis #ReqNOMT 
 // Regression test for FSHARP1.0:6044
 
-#nowarn "44" "49"
+#nowarn "44" "49" "1182"
 
 [<System.Obsolete("Dummy attribute to trigger a warning")>]
 let obsoleteIdentifier = 12
diff --git a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn02.fsx b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn02.fsx
index 02a97bb444e..234344feb5e 100644
--- a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn02.fsx
+++ b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn02.fsx
@@ -1,7 +1,7 @@
 // #Regression #Conformance #LexicalAnalysis #ReqNOMT 
 // Regression test for FSHARP1.0:6044
 
-#nowarn "44" "49"
+#nowarn "44" "49" "1182"
 
 [<System.Obsolete("Dummy attribute to trigger a warning")>]
 let obsoleteIdentifier = 12
diff --git a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn_many.fs b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn_many.fs
index c4c1f6278c7..0a3c54009ba 100644
--- a/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn_many.fs
+++ b/tests/fsharpqa/Source/Conformance/LexicalAnalysis/Directives/multiple_nowarn_many.fs
@@ -3,6 +3,8 @@
 // 100 nowarns...
 #nowarn "01" "02" "03" "04" "05" "06" "07" "08" "09" "10" "11" "12" "13" "14" "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42" "43" "44" "45" "46" "47" "48" "49" "50" "51" "52" "53" "54" "55" "56" "57" "58" "59" "60" "61" "62" "63" "64" "65" "66" "67" "68" "69" "70" "71" "72" "73" "74" "75" "76" "77" "78" "79" "80" "81" "82" "83" "84" "85" "86" "87" "88" "89" "90" "91" "92" "93" "94" "95" "96" "97" "98" "99"
 
+#nowarn "1182"
+
 [<System.Obsolete("Dummy attribute to trigger a warning")>]
 let obsoleteIdentifier = 12
 
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor01.fs b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor01.fs
index 133525b0b00..0708a191955 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor01.fs
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor01.fs
@@ -5,6 +5,8 @@
 
 namespace N
 
+#nowarn "1182"
+
 type T1(``.ctor`` : char) = 
     let ``.ctor`` = 10
     static member ``.ctor ``(``.ctor`` : int) = ``.ctor`` + 1
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor02.fs b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor02.fs
index 92f2123ed62..60f94fbc444 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor02.fs
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/MemberDeclarations/CtorAndCCtor02.fs
@@ -5,6 +5,8 @@
 
 namespace N
 
+#nowarn "1182"
+
 type T2(``.cctor`` : char) = 
     let ``.cctor`` = 10
     static member ``.cctor ``(``.cctor`` : int) = ``.cctor`` + 1
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/ValueRestriction/TypeInferenceVariable01.fsx b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/ValueRestriction/TypeInferenceVariable01.fsx
index baceab8e5db..a629d4562ad 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/ValueRestriction/TypeInferenceVariable01.fsx
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/ClassTypes/ValueRestriction/TypeInferenceVariable01.fsx
@@ -5,5 +5,5 @@
 // We expect no value restriction here. The inferred signature is:
 //     val x0 : ('T -> unit)
 // Here the type inference variable is generalized at 'x0'.
-let f0 (x:obj) = ()
+let f0 (_x:obj) = ()
 let x0 = f0
diff --git a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs
index 8a5ad46511f..af2c64e3c6c 100644
--- a/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs
+++ b/tests/fsharpqa/Source/Conformance/ObjectOrientedTypeDefinitions/StructTypes/Overload_ToString.fs
@@ -4,9 +4,9 @@
 
 [<Struct>]
 type S1 =
-    member this.ToString(s:char) = true
+    member this.ToString(_s:char) = true
     member this.ToString() =       true
-    member this.ToString(?s:char) = true
+    member this.ToString(?_s:char) = true
 
 #if INTERACTIVE
 exit 0;;
diff --git a/tests/fsharpqa/Source/Conformance/UnitsOfMeasure/TypeChecker/Generalization01.fs b/tests/fsharpqa/Source/Conformance/UnitsOfMeasure/TypeChecker/Generalization01.fs
index c46cefad1f4..ea27b64fc69 100644
--- a/tests/fsharpqa/Source/Conformance/UnitsOfMeasure/TypeChecker/Generalization01.fs
+++ b/tests/fsharpqa/Source/Conformance/UnitsOfMeasure/TypeChecker/Generalization01.fs
@@ -9,7 +9,7 @@ type Kg
 
 type M<[<Measure>] 'a> = class end
 
-type T = static member star ( y:'b when 'b :> M<'a>) = 0
+type T = static member star ( _y:'b when 'b :> M<'a>) = 0
 
 let p = 1<Kg>
 let m = Unchecked.defaultof<M<Kg>>
diff --git a/tests/fsharpqa/Source/Diagnostics/General/W_NoValueHasBeenCopiedWarning.fs b/tests/fsharpqa/Source/Diagnostics/General/W_NoValueHasBeenCopiedWarning.fs
index 61315afcef0..7fa76132ea2 100644
--- a/tests/fsharpqa/Source/Diagnostics/General/W_NoValueHasBeenCopiedWarning.fs
+++ b/tests/fsharpqa/Source/Diagnostics/General/W_NoValueHasBeenCopiedWarning.fs
@@ -12,6 +12,6 @@ let main(_) =
        ()
     with 
     | :? 'TException as e -> 
-          let msg = e.ToString()
+          let _msg = e.ToString()
           ()
     0
diff --git a/tests/service/Common.fs b/tests/service/Common.fs
index d0105acca52..4f6f677e2c5 100644
--- a/tests/service/Common.fs
+++ b/tests/service/Common.fs
@@ -136,6 +136,7 @@ let mkProjectCommandLineArgsSilent (dllName, fileNames) =
         yield "--fullpaths"
         yield "--flaterrors"
         yield "--target:library"
+        yield "--nowarn:1182"
         for x in fileNames do
             yield x
         let references = mkStandardProjectReferences ()
@@ -163,6 +164,7 @@ let mkProjectCommandLineArgsForScript (dllName, fileNames) =
         yield "--fullpaths"
         yield "--flaterrors"
         yield "--target:library"
+        yield "--nowarn:1182"
         for x in fileNames do
             yield x
         let references = mkStandardProjectReferences ()
diff --git a/tests/service/data/TestTP/TestTP.fsproj b/tests/service/data/TestTP/TestTP.fsproj
index 75b18586019..1c654bb8113 100644
--- a/tests/service/data/TestTP/TestTP.fsproj
+++ b/tests/service/data/TestTP/TestTP.fsproj
@@ -5,6 +5,7 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <OtherFlags>$(OtherFlags) --nowarn:3390 --nowarn:3218</OtherFlags>
+    <NoWarn>$(NoWarn);3390;3218;1182</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/vsintegration/src/FSharp.VS.FSI/FSharp.VS.FSI.fsproj b/vsintegration/src/FSharp.VS.FSI/FSharp.VS.FSI.fsproj
index a3ce5bb52e2..a3a6304be17 100644
--- a/vsintegration/src/FSharp.VS.FSI/FSharp.VS.FSI.fsproj
+++ b/vsintegration/src/FSharp.VS.FSI/FSharp.VS.FSI.fsproj
@@ -4,7 +4,7 @@
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <NoWarn>$(NoWarn);47;75</NoWarn>
+    <NoWarn>$(NoWarn);47;75;1182</NoWarn>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <OtherFlags>$(OtherFlags) --subsystemversion:6.00</OtherFlags>
     <EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>
diff --git a/vsintegration/tests/GetTypesVS.UnitTests/GetTypesVS.UnitTests.fsproj b/vsintegration/tests/GetTypesVS.UnitTests/GetTypesVS.UnitTests.fsproj
index 4fa4549e645..ee31d516b72 100644
--- a/vsintegration/tests/GetTypesVS.UnitTests/GetTypesVS.UnitTests.fsproj
+++ b/vsintegration/tests/GetTypesVS.UnitTests/GetTypesVS.UnitTests.fsproj
@@ -6,7 +6,7 @@
     <TargetFramework>net472</TargetFramework>
     <PlatformTarget>x86</PlatformTarget>
     <OutputType>Library</OutputType>
-    <NoWarn>$(NoWarn);3005</NoWarn>
+    <NoWarn>$(NoWarn);3005;1182</NoWarn>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UsePackageTargetFallbackHack>true</UsePackageTargetFallbackHack>
     <EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>
diff --git a/vsintegration/tests/MockTypeProviders/DummyProviderForLanguageServiceTesting/DummyProviderForLanguageServiceTesting.fsproj b/vsintegration/tests/MockTypeProviders/DummyProviderForLanguageServiceTesting/DummyProviderForLanguageServiceTesting.fsproj
index 84b50e8a6a7..a53d2c628ec 100644
--- a/vsintegration/tests/MockTypeProviders/DummyProviderForLanguageServiceTesting/DummyProviderForLanguageServiceTesting.fsproj
+++ b/vsintegration/tests/MockTypeProviders/DummyProviderForLanguageServiceTesting/DummyProviderForLanguageServiceTesting.fsproj
@@ -5,7 +5,7 @@
   <PropertyGroup>
     <TargetFramework>net472</TargetFramework>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
-    <OtherFlags>$(OtherFlags) --nowarn:3390 --nowarn:3218</OtherFlags>
+    <NoWarn>$(NoWarn);3390;3218;1182</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/vsintegration/tests/Salsa/VisualFSharp.Salsa.fsproj b/vsintegration/tests/Salsa/VisualFSharp.Salsa.fsproj
index 2cbefb3b41f..b88e9def321 100644
--- a/vsintegration/tests/Salsa/VisualFSharp.Salsa.fsproj
+++ b/vsintegration/tests/Salsa/VisualFSharp.Salsa.fsproj
@@ -5,6 +5,7 @@
   <PropertyGroup>
     <OutputType>Library</OutputType>
     <NoWarn>$(NoWarn);44;45;47;52;58;75</NoWarn>
+    <NoWarn>$(NoWarn);45;47;52;58;75;1182</NoWarn>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UsePackageTargetFallbackHack>true</UsePackageTargetFallbackHack>
     <EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>
diff --git a/vsintegration/tests/UnitTests/DocumentDiagnosticAnalyzerTests.fs b/vsintegration/tests/UnitTests/DocumentDiagnosticAnalyzerTests.fs
index 2f3b76b2965..f1107464f99 100644
--- a/vsintegration/tests/UnitTests/DocumentDiagnosticAnalyzerTests.fs
+++ b/vsintegration/tests/UnitTests/DocumentDiagnosticAnalyzerTests.fs
@@ -124,7 +124,7 @@ type (*start*)=(*end*)
     member public this.AbstractClasses_Constructors_PositiveTests_1() = 
         this.VerifyNoErrors("""
 [<AbstractClass>]
-type C(a : int) = 
+type C(_a : int) = 
     new(a : string) = C(int a)
     new(b) = match b with Some _ -> C(1) | _ -> C("")
             """)
@@ -133,7 +133,7 @@ type C(a : int) =
     member public this.AbstractClasses_Constructors_PositiveTests_2() = 
         this.VerifyNoErrors("""
 [<AbstractClass>]
-type C(a : int) = 
+type C(_a : int) = 
     new(a : string) = new C(int a)
     new(b) = match b with Some _ -> new C(1) | _ -> new C("")
             """)
@@ -142,7 +142,7 @@ type C(a : int) =
     member public this.AbstractClasses_Constructors_PositiveTests_3() = 
         this.VerifyNoErrors("""
 [<AbstractClass>]
-type O(o : int) = 
+type O(_o : int) = 
     new() = O(1)
             """)
 
@@ -150,7 +150,7 @@ type O(o : int) =
     member public this.AbstractClasses_Constructors_PositiveTests_4() = 
         this.VerifyNoErrors("""
 [<AbstractClass>]
-type O(o : int) = 
+type O(_o : int) = 
     new() = O() then printfn "A"
             """)
 
@@ -158,7 +158,7 @@ type O(o : int) =
     member public this.AbstractClasses_Constructors_PositiveTests_5() = 
         this.VerifyNoErrors("""
 [<AbstractClass>]
-type O(o : int) = 
+type O(_o : int) = 
     new() = new O(1) then printfn "A"
             """)
 
@@ -253,7 +253,7 @@ type (*start*)A(*end*) = int * A
         this.VerifyWarningBetweenMarkers(
             fileContents = """
 [<System.Obsolete("x")>]
-let fn x = 0
+let fn _x = 0
 let y = (*start*)fn(*end*) 1
             """,
             expectedMessage = "This construct is deprecated. x")
@@ -282,7 +282,7 @@ let r = (*start*)f 3(*end*) 4
         this.VerifyWarningBetweenMarkers(
             fileContents = """
 let a = async {
-    let! (*start*)[| r1; r2 |](*end*) = Async.Parallel [| async.Return(1); async.Return(2) |]
+    let! (*start*)[| _r1; _r2 |](*end*) = Async.Parallel [| async.Return(1); async.Return(2) |]
     let yyyy = 4
     return r1,r2
 }
@@ -293,7 +293,7 @@ let a = async {
     member public this.InComputationExpression_Bug6095_B() =
         this.VerifyWarningBetweenMarkers(
             fileContents = """
-let f = (*start*)function(*end*) | [| a;b |] -> ()
+let f = (*start*)function(*end*) | [| _a;_b |] -> ()
             """,
             expectedMessage = "Incomplete pattern matches on this expression. For example, the value '[|_; _; _|]' may indicate a case not covered by the pattern(s).")
 
@@ -301,7 +301,7 @@ let f = (*start*)function(*end*) | [| a;b |] -> ()
     member public this.InComputationExpression_Bug6095_C() =
         this.VerifyWarningBetweenMarkers(
             fileContents = """
-for (*start*)[|a;b|](*end*) in [| [|42|] |] do ()
+for (*start*)[|_a;_b|](*end*) in [| [|42|] |] do ()
             """,
             expectedMessage = "Incomplete pattern matches on this expression. For example, the value '[|_; _; _|]' may indicate a case not covered by the pattern(s). Unmatched elements will be ignored.")
             
diff --git a/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.ErrorList.fs b/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.ErrorList.fs
index aff227acd96..608fcc2710b 100644
--- a/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.ErrorList.fs
+++ b/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.ErrorList.fs
@@ -561,7 +561,7 @@ but here has type
     member public this.``NoError.FlagsAndSettings.TargetOptionsRespected``() =
         let fileContent = """
             [<System.Obsolete("x")>]
-            let fn x = 0
+            let fn _x = 0
             let y = fn 1"""
         // Turn off the "Obsolete" warning.
         let (solution, project, file) = this.CreateSingleFileProject(fileContent, disabledWarnings = ["44"])
@@ -654,15 +654,15 @@ but here has type
             fileContents = """
                 #nowarn "47"
 
-                type Fruit (shelfLife : int) as x =
+                type Fruit (_shelfLife : int) as x =
     
-                        let mutable m_age = (fun () -> x)
+                        let mutable _m_age = (fun () -> x)
 
 
                 #nowarn "25" // FS0025: Incomplete pattern matches on this expression. For example, the value 'C' 
 
                 type DU = A | B | C
-                let f x = function A -> true | B -> false
+                let f _x = function A -> true | B -> false
 
 
                 #nowarn "58" // FS0058: possible incorrect indentation: this token is offside of context started at
diff --git a/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.Script.fs b/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.Script.fs
index ea2d28ad606..e8e4c25e72b 100644
--- a/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.Script.fs
+++ b/vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.Script.fs
@@ -15,31 +15,31 @@ open UnitTests.TestLib.ProjectSystem
 
 [<TestFixture>]
 [<Category "LanguageService">]
-type UsingMSBuild() as this = 
-    inherit LanguageServiceBaseTests() 
+type UsingMSBuild() as this =
+    inherit LanguageServiceBaseTests()
 
     let notAA l = None,l
 
-    let createSingleFileFsx (code : string) = 
+    let createSingleFileFsx (code : string) =
         let (_, p, f) = this.CreateSingleFileProject(code, fileKind = SourceFileKind.FSX)
         (p, f)
 
-    let createSingleFileFsxFromLines (code : list<string>) = 
+    let createSingleFileFsxFromLines (code : list<string>) =
         let (_, p, f) = this.CreateSingleFileProject(code, fileKind = SourceFileKind.FSX)
         (p, f)
 
     (* Timings ----------------------------------------------------------------------------- *)
     let stopWatch = new System.Diagnostics.Stopwatch()
     let ResetStopWatch() = stopWatch.Reset(); stopWatch.Start()
-    let time1 op a message = 
+    let time1 op a message =
         ResetStopWatch()
         let result = op a
         printf "%s %d ms\n" message stopWatch.ElapsedMilliseconds
         result
 
-    let ShowErrors(project:OpenProject) =     
+    let ShowErrors(project:OpenProject) =
         for error in (GetErrors(project)) do
-            printf "%s\n" (error.ToString())  
+            printf "%s\n" (error.ToString())
 
     let AssertListContainsInOrder(s:string list,cs:string list) =
         let s : string array = Array.ofList s
@@ -47,68 +47,68 @@ type UsingMSBuild() as this =
         AssertContainsInOrder(s,cs)
 
     /// Assert that there is no squiggle.
-    let AssertNoSquiggle(squiggleOption) = 
-        match squiggleOption with 
+    let AssertNoSquiggle(squiggleOption) =
+        match squiggleOption with
         | None -> ()
         | Some(severity,message) ->
             Assert.Fail(sprintf "Expected no squiggle but got '%A' with message: %s" severity message)
 
-    let VerifyErrorListContainedExpetedStr(expectedStr:string,project : OpenProject) = 
+    let VerifyErrorListContainedExpetedStr(expectedStr:string,project : OpenProject) =
         let errorList = GetErrors(project)
         let GetErrorMessages(errorList : Error list) =
             [ for i = 0 to errorList.Length - 1 do
                 yield errorList.[i].Message]
-            
+
         Assert.IsTrue(errorList
                           |> GetErrorMessages
                           |> Seq.exists (fun errorMessage ->
                                 errorMessage.Contains(expectedStr)))
 
-    let AssertNoErrorsOrWarnings(project:OpenProject) = 
+    let AssertNoErrorsOrWarnings(project:OpenProject) =
         let count = List.length (GetErrors(project))
         if count<>0 then
             printf "Saw %d errors and expected none.\n" count
-            printf "Errors are: \n" 
-            for e in GetErrors project do 
+            printf "Errors are: \n"
+            for e in GetErrors project do
                 printf "  path = <<<%s>>>\n" e.Path
-                printf "  message = <<<%s> \n" e.Message 
+                printf "  message = <<<%s> \n" e.Message
             AssertEqual(0,count)
 
     let AssertExactlyCountErrorSeenContaining(project:OpenProject,text,expectedCount) =
         let nMatching = (GetErrors(project)) |> List.filter (fun e ->e.ToString().Contains(text)) |> List.length
         match nMatching with
-        | 0 -> 
+        | 0 ->
             failwith (sprintf "No errors containing \"%s\"" text)
         | x when x = expectedCount -> ()
-        | _ -> 
+        | _ ->
             failwith (sprintf "Multiple errors containing \"%s\"" text)
 
     let AssertExactlyOneErrorSeenContaining(project:OpenProject,text) =
         AssertExactlyCountErrorSeenContaining(project,text,1)
 
-    /// Assert that a given squiggle is an Error (or warning) containing the given text        
-    let AssertSquiggleIsErrorContaining,AssertSquiggleIsWarningContaining, AssertSquiggleIsErrorNotContaining,AssertSquiggleIsWarningNotContaining =         
-        let AssertSquiggle expectedSeverity nameOfExpected nameOfNotExpected assertf (squiggleOption,containing) = 
+    /// Assert that a given squiggle is an Error (or warning) containing the given text
+    let AssertSquiggleIsErrorContaining,AssertSquiggleIsWarningContaining, AssertSquiggleIsErrorNotContaining,AssertSquiggleIsWarningNotContaining =
+        let AssertSquiggle expectedSeverity nameOfExpected nameOfNotExpected assertf (squiggleOption,containing) =
             match squiggleOption with
             | None -> Assert.Fail("Expected a squiggle but none was seen.")
             | Some(severity,message) ->
                 Assert.IsTrue((severity=expectedSeverity), sprintf "Expected %s but saw %s: %s" nameOfExpected nameOfNotExpected message)
-                assertf(message,containing)        
+                assertf(message,containing)
         AssertSquiggle Microsoft.VisualStudio.FSharp.LanguageService.Severity.Error    "Error"    "Warning" AssertContains,
         AssertSquiggle Microsoft.VisualStudio.FSharp.LanguageService.Severity.Warning  "Warning"  "Error"   AssertContains,
         AssertSquiggle Microsoft.VisualStudio.FSharp.LanguageService.Severity.Error    "Error"    "Warning" AssertNotContains,
-        AssertSquiggle Microsoft.VisualStudio.FSharp.LanguageService.Severity.Warning  "Warning"  "Error"   AssertNotContains 
+        AssertSquiggle Microsoft.VisualStudio.FSharp.LanguageService.Severity.Warning  "Warning"  "Error"   AssertNotContains
 
 
     //Verify the error list in fsx file containd the expected string
     member private this.VerifyFSXErrorListContainedExpectedString(fileContents : string, expectedStr : string) =
         let (_, project, file) = this.CreateSingleFileProject(fileContents, fileKind = SourceFileKind.FSX)
-        VerifyErrorListContainedExpetedStr(expectedStr,project)    
+        VerifyErrorListContainedExpetedStr(expectedStr,project)
 
-    //Verify no error list in fsx file 
+    //Verify no error list in fsx file
     member private this.VerifyFSXNoErrorList(fileContents : string) =
         let (_, project, file) = this.CreateSingleFileProject(fileContents, fileKind = SourceFileKind.FSX)
-        AssertNoErrorsOrWarnings(project)  
+        AssertNoErrorsOrWarnings(project)
     //Verify QuickInfo Containd In Fsx file
     member public this.AssertQuickInfoContainsAtEndOfMarkerInFsxFile (code : string) marker expected =
 
@@ -124,7 +124,7 @@ type UsingMSBuild() as this =
         MoveCursorToStartOfMarker(file, marker)
         let tooltip = GetQuickInfoAtCursor file
         AssertContains(tooltip, expected)
-    //Verify QuickInfo Not Containd In Fsx file     
+    //Verify QuickInfo Not Containd In Fsx file
     member public this.AssertQuickInfoNotContainsAtEndOfMarkerInFsxFile code marker notexpected =
         let (_, _, file) = this.CreateSingleFileProject((code : string), fileKind = SourceFileKind.FSX)
 
@@ -134,94 +134,94 @@ type UsingMSBuild() as this =
 
     /// There was a problem with Salsa that caused squiggles not to be shown for .fsx files.
     [<Test>]
-    member public this.``Fsx.Squiggles.ShowInFsxFiles``() =  
+    member public this.``Fsx.Squiggles.ShowInFsxFiles``() =
         let fileContent = """open Thing1.Thing2"""
         this.VerifyFSXErrorListContainedExpectedString(fileContent,"Thing1")
-        
+
     /// Regression test for FSharp1.0:4861 - #r to non-existent file causes the first line to be squiggled
     /// There was a problem with Salsa that caused squiggles not to be shown for .fsx files.
     [<Test>]
-    member public this.``Fsx.Hash.RProperSquiggleForNonExistentFile``() =  
+    member public this.``Fsx.Hash.RProperSquiggleForNonExistentFile``() =
         let fileContent = """#r "NonExistent" """
-        this.VerifyFSXErrorListContainedExpectedString(fileContent,"was not found or is invalid") 
+        this.VerifyFSXErrorListContainedExpectedString(fileContent,"was not found or is invalid")
 
     /// Nonexistent hash. There was a problem with Salsa that caused squiggles not to be shown for .fsx files.
     [<Test>]
-    member public this.``Fsx.Hash.RDoesNotExist.Bug3325``() =  
+    member public this.``Fsx.Hash.RDoesNotExist.Bug3325``() =
         let fileContent = """#r "ThisDLLDoesNotExist" """
-        this.VerifyFSXErrorListContainedExpectedString(fileContent,"'ThisDLLDoesNotExist' was not found or is invalid") 
+        this.VerifyFSXErrorListContainedExpectedString(fileContent,"'ThisDLLDoesNotExist' was not found or is invalid")
 
     // There was a spurious error message on the first line.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.Bug4861``() =  
-        let code = 
+    member public this.``Fsx.ExactlyOneError.Bug4861``() =
+        let code =
                                       ["#light" // First line is important in this repro
                                        "#r \"Nonexistent\""
                                        ]
         let (project, _) = createSingleFileFsxFromLines code
         AssertExactlyCountErrorSeenContaining(project, "Nonexistent", 2)   // ...and not an error on the first line.
-        
+
     [<Test>]
-    member public this.``Fsx.InvalidHashLoad.ShouldBeASquiggle.Bug3012``() =  
+    member public this.``Fsx.InvalidHashLoad.ShouldBeASquiggle.Bug3012``() =
         let fileContent = """
             #light
             #load "Bar.fs"
             """
-        this.VerifyFSXErrorListContainedExpectedString(fileContent,"Bar.fs") 
+        this.VerifyFSXErrorListContainedExpectedString(fileContent,"Bar.fs")
 
     // Transitive to existing property.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ScriptClosure.TransitiveLoad1``() = 
-        use _guard = this.UsingNewVS() 
+    member public this.``Fsx.ScriptClosure.TransitiveLoad1``() =
+        use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public Property = 0"
-                                     ])    
-        let file1 = OpenFile(project,"File1.fs")   
+                                     ])
+        let file1 = OpenFile(project,"File1.fs")
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"File1.fs\""
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
         let script2 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"Script1.fsx\""
-                                       "Namespace.Foo.Property" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
+                                       "Namespace.Foo.Property"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
         TakeCoffeeBreak(this.VS)
         AssertNoErrorsOrWarnings(project)
 
     // Transitive to nonexisting property.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ScriptClosure.TransitiveLoad2``() = 
-        use _guard = this.UsingNewVS()  
+    member public this.``Fsx.ScriptClosure.TransitiveLoad2``() =
+        use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"File1.fs\""
-                                       ])    
+                                       ])
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"Script2.fsx\""
-                                       "Namespace.Foo.NonExistingProperty" 
-                                       ])    
-        let script1 = OpenFile(project,"Script1.fsx")   
+                                       "Namespace.Foo.NonExistingProperty"
+                                       ])
+        let script1 = OpenFile(project,"Script1.fsx")
         TakeCoffeeBreak(this.VS)
         AssertExactlyOneErrorSeenContaining(project, "NonExistingProperty")
 
     /// FEATURE: Typing a #r into a file will cause it to be recognized by intellisense.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.HashR.AddedIn``() =  
+    member public this.``Fsx.HashR.AddedIn``() =
         let code =
                                     ["#light"
                                      "//#r \"System.Transactions.dll\"" // Pick anything that isn't in the standard set of assemblies.
@@ -229,7 +229,7 @@ type UsingMSBuild() as this =
                                      ]
         let (project, file) = createSingleFileFsxFromLines code
         VerifyErrorListContainedExpetedStr("Transactions",project)
-        
+
         let gpatcc = GlobalParseAndTypeCheckCounter.StartNew(this.VS)
         ReplaceFileInMemory file
                         ["#light"
@@ -241,29 +241,29 @@ type UsingMSBuild() as this =
 
     // FEATURE: Adding a #load to a file will cause types from that file to be visible in intellisense
     [<Test>]
-    member public this.``Fsx.HashLoad.Added``() =  
+    member public this.``Fsx.HashLoad.Added``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
         let fs = AddFileFromText(project,"File1.fs",
                                     ["#light"
-                                     "namespace MyNamespace" 
+                                     "namespace MyNamespace"
                                      "    module MyModule ="
-                                     "        let x = 1" 
-                                     ])            
-        
+                                     "        let x = 1"
+                                     ])
+
         let fsx = AddFileFromText(project,"File2.fsx",
                                     ["#light"
-                                     "//#load \"File1.fs\"" 
+                                     "//#load \"File1.fs\""
                                      "open MyNamespace.MyModule"
                                      "printfn \"%d\" x"
-                                     ])    
-        let fsx = OpenFile(project,"File2.fsx")    
+                                     ])
+        let fsx = OpenFile(project,"File2.fsx")
         VerifyErrorListContainedExpetedStr("MyNamespace",project)
-        
+
         ReplaceFileInMemory fsx
                          ["#light"
-                          "#load \"File1.fs\"" 
+                          "#load \"File1.fs\""
                           "open MyNamespace.MyModule"
                           "printfn \"%d\" x"
                           ]
@@ -272,35 +272,35 @@ type UsingMSBuild() as this =
 
     // FEATURE: Removing a #load to a file will cause types from that file to no longer be visible in intellisense
     [<Test>]
-    member public this.``Fsx.HashLoad.Removed``() =  
+    member public this.``Fsx.HashLoad.Removed``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
         let fs = AddFileFromText(project,"File1.fs",
                                     ["#light"
-                                     "namespace MyNamespace" 
+                                     "namespace MyNamespace"
                                      "    module MyModule ="
-                                     "        let x = 1" 
-                                     ])            
-        
+                                     "        let x = 1"
+                                     ])
+
         let fsx = AddFileFromText(project,"File2.fsx",
                                     ["#light"
-                                     "#load \"File1.fs\"" 
+                                     "#load \"File1.fs\""
                                      "open MyNamespace.MyModule"
                                      "printfn \"%d\" x"
-                                     ])    
-        let fsx = OpenFile(project,"File2.fsx")    
+                                     ])
+        let fsx = OpenFile(project,"File2.fsx")
         AssertNoErrorsOrWarnings(project)
-        
+
         ReplaceFileInMemory fsx
                          ["#light"
-                          "//#load \"File1.fs\"" 
+                          "//#load \"File1.fs\""
                           "open MyNamespace.MyModule"
                           "printfn \"%d\" x"
                           ]
         TakeCoffeeBreak(this.VS)
         VerifyErrorListContainedExpetedStr("MyNamespace",project)
-    
+
     [<Test>]
     member public this.``Fsx.HashLoad.Conditionals``() =
         use _guard = this.UsingNewVS()
@@ -318,13 +318,13 @@ type UsingMSBuild() as this =
                                      "#else"
                                      "let B = 4"
                                      "#endif"
-                                     ])            
-        
+                                     ])
+
         let fsx = AddFileFromText(project,"File2.fsx",
                                     [
-                                     "#load \"File1.fs\"" 
+                                     "#load \"File1.fs\""
                                      "InDifferentFS."
-                                     ])    
+                                     ])
         let fsx = OpenFile(project,"File2.fsx")
 
         MoveCursorToEndOfMarker(fsx, "InDifferentFS.")
@@ -333,12 +333,12 @@ type UsingMSBuild() as this =
         Assert.AreEqual(Set.count completion, 2, "Expected 2 elements in the completion list")
         Assert.IsTrue(completion.Contains "x", "Completion list should contain x because INTERACTIVE is defined")
         Assert.IsTrue(completion.Contains "B", "Completion list should contain B because DEBUG is not defined")
-        
+
 
     /// FEATURE: Removing a #r into a file will cause it to no longer be seen by intellisense.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.HashR.Removed``() =  
+    member public this.``Fsx.HashR.Removed``() =
         let code =
                                     ["#light"
                                      "#r \"System.Transactions.dll\"" // Pick anything that isn't in the standard set of assemblies.
@@ -346,8 +346,8 @@ type UsingMSBuild() as this =
                                      ]
         let (project, file) = createSingleFileFsxFromLines code
         TakeCoffeeBreak(this.VS)
-        AssertNoErrorsOrWarnings(project)  
-        
+        AssertNoErrorsOrWarnings(project)
+
         let gpatcc = GlobalParseAndTypeCheckCounter.StartNew(this.VS)
         ReplaceFileInMemory file
                         ["#light"
@@ -358,184 +358,184 @@ type UsingMSBuild() as this =
         TakeCoffeeBreak(this.VS)
         VerifyErrorListContainedExpetedStr("Transactions",project)
         gpatcc.AssertExactly(notAA[file], notAA[file], true (* expectCreate, because dependent DLL set changed *))
-    
+
 
 
     // Corecursive load to existing property.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad3``() =  
+    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad3``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
                                        "#load \"File1.fs\""
-                                       ])    
+                                       ])
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"Script2.fsx\""
                                        "#load \"File1.fs\""
-                                       "Namespace.Foo.Property" 
-                                       ])    
-        let script1 = OpenFile(project,"Script1.fsx")   
+                                       "Namespace.Foo.Property"
+                                       ])
+        let script1 = OpenFile(project,"Script1.fsx")
         TakeCoffeeBreak(this.VS)
         AssertNoErrorsOrWarnings(project)
-        
+
     // #load of .fsi is respected (for non-hidden property)
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad9``() =  
+    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad9``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fsi\""
                                        "#load \"File1.fs\""
-                                       "Namespace.Foo.Property" 
-                                       ])     
-        let script1 = OpenFile(project,"Script1.fsx")   
-        AssertNoErrorsOrWarnings(project) 
+                                       "Namespace.Foo.Property"
+                                       ])
+        let script1 = OpenFile(project,"Script1.fsx")
+        AssertNoErrorsOrWarnings(project)
 
-    // #load of .fsi is respected at second #load level (for non-hidden property) 
+    // #load of .fsi is respected at second #load level (for non-hidden property)
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad10``() =  
+    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad10``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fsi\""
                                        "#load \"File1.fs\""
-                                       ])     
+                                       ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
-                                       "Namespace.Foo.Property" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
-        AssertNoErrorsOrWarnings(project) 
+                                       "Namespace.Foo.Property"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
+        AssertNoErrorsOrWarnings(project)
 
     // #load of .fsi is respected when dispersed between two #load levels (for non-hidden property)
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad11``() =  
+    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad11``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fsi\""
-                                       ])     
+                                       ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
                                        "#load \"File1.fs\""
-                                       "Namespace.Foo.Property" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
-        AssertNoErrorsOrWarnings(project)  
-        
+                                       "Namespace.Foo.Property"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
+        AssertNoErrorsOrWarnings(project)
+
     // #load of .fsi is respected when dispersed between two #load levels (the other way) (for non-hidden property)
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad12``() =  
+    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad12``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fs\""
-                                       ])     
+                                       ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"File1.fsi\""
                                        "#load \"Script1.fsx\""
-                                       "Namespace.Foo.Property" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
-        AssertNoErrorsOrWarnings(project)  
-        
+                                       "Namespace.Foo.Property"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
+        AssertNoErrorsOrWarnings(project)
+
     // #nowarn seen in closed .fsx is global to the closure
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad16``() =  
+    member public this.``Fsx.NoError.ScriptClosure.TransitiveLoad16``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let thisProject = AddFileFromText(project,"ThisProject.fsx",
                                       ["#nowarn \"44\""
-                                       ])  
+                                       ])
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"ThisProject.fsx\"" // Should bring in #nowarn "44" so we don't see this warning:
                                        "[<System.Obsolete(\"x\")>]"
-                                       "let fn x = 0"
+                                       "let fn _x = 0"
                                        "let y = fn 1"
-                                       ])                                                   
+                                       ])
 
-        let script1 = OpenFile(project,"Script1.fsx")   
-        MoveCursorToEndOfMarker(script1,"let y = f") 
-        TakeCoffeeBreak(this.VS) 
-        AssertNoErrorsOrWarnings(project)   
+        let script1 = OpenFile(project,"Script1.fsx")
+        MoveCursorToEndOfMarker(script1,"let y = f")
+        TakeCoffeeBreak(this.VS)
+        AssertNoErrorsOrWarnings(project)
 
     /// FEATURE: #r in .fsx to a .dll name works.
     [<Test>]
-    member public this.``Fsx.NoError.HashR.DllWithNoPath``() =  
+    member public this.``Fsx.NoError.HashR.DllWithNoPath``() =
         let fileContent = """
             #light
             #r "System.Transactions.dll"
@@ -545,7 +545,7 @@ type UsingMSBuild() as this =
 
     [<Test>]
     // 'System' is in the default set. Make sure we can still resolve it.
-    member public this.``Fsx.NoError.HashR.BugDefaultReferenceFileIsAlsoResolved``() =  
+    member public this.``Fsx.NoError.HashR.BugDefaultReferenceFileIsAlsoResolved``() =
         let fileContent = """
             #light
             #r "System"
@@ -554,7 +554,7 @@ type UsingMSBuild() as this =
 
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoError.HashR.DoubleReference``() =  
+    member public this.``Fsx.NoError.HashR.DoubleReference``() =
         let fileContent = """
             #light
             #r "System"
@@ -565,7 +565,7 @@ type UsingMSBuild() as this =
     [<Test>]
     [<Category("fsx closure")>]
     // 'CustomMarshalers' is loaded from the GAC _and_ it is available on XP and above.
-    member public this.``Fsx.NoError.HashR.ResolveFromGAC``() =  
+    member public this.``Fsx.NoError.HashR.ResolveFromGAC``() =
         let fileContent = """
             #light
             #r "CustomMarshalers"
@@ -591,14 +591,14 @@ type UsingMSBuild() as this =
                                     ["module Lib"
                                      "let X = 42"
                                      ])
-        
+
         let bld = Build(project)
 
         let script1Dir = Path.Combine(ProjectDirectory(project), "ccc")
         let script1Path = Path.Combine(script1Dir, "Script1.fsx")
         let script2Dir = Path.Combine(ProjectDirectory(project), "aaa\\bbb")
         let script2Path = Path.Combine(script2Dir, "Script2.fsx")
-        
+
         Directory.CreateDirectory(script1Dir) |> ignore
         Directory.CreateDirectory(script2Dir) |> ignore
         File.Move(bld.ExecutableOutput, Path.Combine(ProjectDirectory(project), "aaa\\lib.exe"))
@@ -611,17 +611,17 @@ type UsingMSBuild() as this =
                                       ["#r \"../lib.exe\""
                                        ])
 
-        let script1 = OpenFile(project, script1Path)   
+        let script1 = OpenFile(project, script1Path)
         TakeCoffeeBreak(this.VS)
-        
+
         MoveCursorToEndOfMarker(script1,"#load")
         let ans = GetSquiggleAtCursor(script1)
         AssertNoSquiggle(ans)
 
     [<Test; Category("fsx closure")>]
     [<Ignore("Re-enable this test --- https://github.com/Microsoft/visualfsharp/issues/5238")>]
-    member public this.``Fsx.NoError.HashR.RelativePath2``() = 
-        use _guard = this.UsingNewVS()  
+    member public this.``Fsx.NoError.HashR.RelativePath2``() =
+        use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
         let file1 = AddFileFromText(project,"lib.fs",
@@ -635,7 +635,7 @@ type UsingMSBuild() as this =
         let script1Path = Path.Combine(script1Dir, "Script1.fsx")
         let script2Dir = Path.Combine(ProjectDirectory(project), "aaa")
         let script2Path = Path.Combine(script2Dir, "Script2.fsx")
-        
+
         Directory.CreateDirectory(script1Dir) |> ignore
         Directory.CreateDirectory(script2Dir) |> ignore
         File.Move(bld.ExecutableOutput, Path.Combine(ProjectDirectory(project), "aaa\\lib.exe"))
@@ -647,60 +647,60 @@ type UsingMSBuild() as this =
         let script2 = File.WriteAllLines(script2Path,
                                       ["#r \"lib.exe\""
                                        ])
-                                       
-        let script1 = OpenFile(project, script1Path)   
+
+        let script1 = OpenFile(project, script1Path)
         TakeCoffeeBreak(this.VS)
-        
+
         MoveCursorToEndOfMarker(script1,"#load")
         let ans = GetSquiggleAtCursor(script1)
         AssertNoSquiggle(ans)
 
      /// FEATURE: #load in an .fsx file will include that file in the 'build' of the .fsx.
     [<Test>]
-    member public this.``Fsx.NoError.HashLoad.Simple``() =  
+    member public this.``Fsx.NoError.HashLoad.Simple``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
         let fs = AddFileFromText(project,"File1.fs",
                                     ["#light"
-                                     "namespace MyNamespace" 
+                                     "namespace MyNamespace"
                                      "    module MyModule ="
-                                     "        let x = 1" 
-                                     ])            
-        
+                                     "        let x = 1"
+                                     ])
+
         let fsx = AddFileFromText(project,"File2.fsx",
                                     ["#light"
-                                     "#load \"File1.fs\"" 
+                                     "#load \"File1.fs\""
                                      "open MyNamespace.MyModule"
                                      "printfn \"%d\" x"
-                                     ])    
-        let fsx = OpenFile(project,"File2.fsx")    
+                                     ])
+        let fsx = OpenFile(project,"File2.fsx")
         AssertNoErrorsOrWarnings(project)
 
     // In this bug the #loaded file contains a level-4 warning (copy to avoid mutation). This warning was reported at the #load in file2.fsx but shouldn't have been.s
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.NoWarn.OnLoadedFile.Bug4837``() =  
+    member public this.``Fsx.NoWarn.OnLoadedFile.Bug4837``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
         let fs = AddFileFromText(project,"File1.fs",
                                     ["module File1Module"
                                      "let x = System.DateTime.Now - System.DateTime.Now"
-                                     "x.Add(x) |> ignore" 
-                                     ])            
-        
+                                     "x.Add(x) |> ignore"
+                                     ])
+
         let fsx = AddFileFromText(project,"File2.fsx",
                                     [
-                                     "#load \"File1.fs\"" 
-                                     ])    
-        let fsx = OpenFile(project,"File2.fsx")    
-        AssertNoErrorsOrWarnings(project) 
+                                     "#load \"File1.fs\""
+                                     ])
+        let fsx = OpenFile(project,"File2.fsx")
+        AssertNoErrorsOrWarnings(project)
 
     /// FEATURE: .fsx files have automatic imports of certain system assemblies.
     //There is a test bug here. The actual scenario works. Need to revisit.
     [<Test>]
-    [<Category("ReproX")>]  
+    [<Category("ReproX")>]
     member public this.``Fsx.NoError.AutomaticImportsForFsxFiles``() =
         let fileContent = """
             #light
@@ -714,186 +714,186 @@ type UsingMSBuild() as this =
             open System.Web
             open System.Web.Services
             open System.Windows.Forms"""
-        this.VerifyFSXNoErrorList(fileContent) 
+        this.VerifyFSXNoErrorList(fileContent)
 
     // Corecursive load to nonexisting property.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad4``() =  
+    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad4``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
                                        "#load \"File1.fs\""
-                                       ])    
+                                       ])
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"Script2.fsx\""
                                        "#load \"File1.fs\""
-                                       "Namespace.Foo.NonExistingProperty" 
-                                       ])     
-        let script1 = OpenFile(project,"Script1.fsx")   
-        AssertExactlyOneErrorSeenContaining(project, "NonExistingProperty")  
+                                       "Namespace.Foo.NonExistingProperty"
+                                       ])
+        let script1 = OpenFile(project,"Script1.fsx")
+        AssertExactlyOneErrorSeenContaining(project, "NonExistingProperty")
 
     // #load of .fsi is respected
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad5``() =  
+    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad5``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fsi\""
                                        "#load \"File1.fs\""
-                                       "Namespace.Foo.HiddenProperty" 
-                                       ])     
-        let script1 = OpenFile(project,"Script1.fsx")   
-        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")   
+                                       "Namespace.Foo.HiddenProperty"
+                                       ])
+        let script1 = OpenFile(project,"Script1.fsx")
+        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")
 
     // #load of .fsi is respected at second #load level
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad6``() =  
+    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad6``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fsi\""
                                        "#load \"File1.fs\""
-                                       ])     
+                                       ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
-                                       "Namespace.Foo.HiddenProperty" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
-        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty") 
-        
+                                       "Namespace.Foo.HiddenProperty"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
+        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")
+
     // #load of .fsi is respected when dispersed between two #load levels
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad7``() =  
+    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad7``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fsi\""
-                                       ])     
+                                       ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
                                        "#load \"File1.fs\""
-                                       "Namespace.Foo.HiddenProperty" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
-        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")    
-        
+                                       "Namespace.Foo.HiddenProperty"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
+        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")
+
     // #load of .fsi is respected when dispersed between two #load levels (the other way)
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad8``() =  
+    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad8``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file1fsi = AddFileFromText(project,"File1.fsi",
                                       ["namespace Namespace"
                                        "type Foo ="
                                        "  class"
                                        "    static member Property : int" // Not exposing 'HiddenProperty'
                                        "  end"
-                                       ])            
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                     ["namespace Namespace"
                                      "type Foo = "
                                      "     static member public HiddenProperty = 0"
                                      "     static member public Property = 0"
-                                     ])    
+                                     ])
 
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fs\""
-                                       ])     
+                                       ])
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"File1.fsi\""
                                        "#load \"Script1.fsx\""
-                                       "Namespace.Foo.HiddenProperty" 
-                                       ])    
-        let script2 = OpenFile(project,"Script2.fsx")   
-        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")   
-        
+                                       "Namespace.Foo.HiddenProperty"
+                                       ])
+        let script2 = OpenFile(project,"Script2.fsx")
+        AssertExactlyOneErrorSeenContaining(project, "HiddenProperty")
+
     // Bug seen during development: A #load in an .fs would be followed.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad15``() =  
+    member public this.``Fsx.ExactlyOneError.ScriptClosure.TransitiveLoad15``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let file2 = AddFileFromText(project,"File2.fs",
                                       ["namespace Namespace"
                                        "type Type() ="
                                        "    static member Property = 0"
-                                       ])  
+                                       ])
         let file1 = AddFileFromText(project,"File1.fs",
                                       ["#load \"File2.fs\""  // This is not allowed but it was working anyway.
                                        "namespace File2Namespace"
-                                       ])                                              
+                                       ])
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"File1.fs\""
                                        "Namespace.Type.Property"
-                                       ])                                                   
+                                       ])
 
-        let script1 = OpenFile(project,"Script1.fsx")   
+        let script1 = OpenFile(project,"Script1.fsx")
         TakeCoffeeBreak(this.VS)
-        AssertExactlyOneErrorSeenContaining(project, "Namespace")  
+        AssertExactlyOneErrorSeenContaining(project, "Namespace")
 
     [<Test>]
     member public this.``Fsx.Bug4311HoverOverReferenceInFirstLine``() =
         let fileContent = """#r "PresentationFramework.dll"
-                             
+
                              #r "PresentationCore.dll" """
         let marker = "#r \"PresentationFrame"
         this.AssertQuickInfoContainsAtEndOfMarkerInFsxFile fileContent marker "PresentationFramework.dll"
@@ -901,19 +901,19 @@ type UsingMSBuild() as this =
 
     [<Test>]
     member public this.``Fsx.QuickInfo.Bug4979``() =
-        let code = 
+        let code =
                 ["System.ConsoleModifiers.Shift |> ignore "
                  "(3).ToString().Length |> ignore "]
         let (project, file) = createSingleFileFsxFromLines code
         MoveCursorToEndOfMarker(file, "System.ConsoleModifiers.Sh")
         let tooltip = GetQuickInfoAtCursor file
-        AssertContains(tooltip, @"<summary>The left or right SHIFT modifier key.</summary>")    
-        
+        AssertContains(tooltip, @"<summary>The left or right SHIFT modifier key.</summary>")
+
         MoveCursorToEndOfMarker(file, "(3).ToString().Len")
         let tooltip = GetQuickInfoAtCursor file
         AssertContains(tooltip, @"[Signature:P:System.String.Length]") // A message from the mock IDocumentationBuilder
-        AssertContains(tooltip, @"[Filename:") 
-        AssertContains(tooltip, @"netstandard.dll]") // The assembly we expect the documentation to get taken from  
+        AssertContains(tooltip, @"[Filename:")
+        AssertContains(tooltip, @"netstandard.dll]") // The assembly we expect the documentation to get taken from
 
     // Especially under 4.0 we need #r of .NET framework assemblies to resolve from like,
     //
@@ -944,25 +944,25 @@ type UsingMSBuild() as this =
         this.AssertQuickInfoContainsAtEndOfMarkerInFsxFile
             """#r "System" """  // 'System' is in the default set. Make sure we can still resolve it.
             "#r \"Syst" "System.dll"
-        
+
     [<Test>]
     [<Category("fsx closure")>]
     member public this.``Fsx.HashR_QuickInfo.DoubleReference``() =
         let fileContent = """#r "System" // Mark1
-                             #r "System" // Mark2 """   // The same reference repeated twice. 
+                             #r "System" // Mark2 """   // The same reference repeated twice.
         this.AssertQuickInfoContainsAtStartOfMarkerInFsxFile fileContent "tem\" // Mark1" "System.dll"
         this.AssertQuickInfoContainsAtStartOfMarkerInFsxFile fileContent "tem\" // Mark2" "System.dll"
-        
+
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.HashR_QuickInfo.ResolveFromGAC``() = 
+    member public this.``Fsx.HashR_QuickInfo.ResolveFromGAC``() =
         this.AssertQuickInfoContainsAtEndOfMarkerInFsxFile
             """#r "CustomMarshalers" """        // 'mscorcfg' is loaded from the GAC _and_ it is available on XP and above.
             "#r \"Custo" ".NET Framework"
 
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.HashR_QuickInfo.ResolveFromFullyQualifiedPath``() = 
+    member public this.``Fsx.HashR_QuickInfo.ResolveFromFullyQualifiedPath``() =
         let fullyqualifiepathtoddll = System.IO.Path.Combine( System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(), "System.configuration.dll" ) // Can be any fully qualified path to an assembly
         let expectedtooltip = System.Reflection.Assembly.ReflectionOnlyLoadFrom(fullyqualifiepathtoddll).FullName
         let fileContent = "#r @\"" + fullyqualifiepathtoddll + "\""
@@ -971,12 +971,12 @@ type UsingMSBuild() as this =
         //this.AssertQuickInfoNotContainsAtEndOfMarkerInFsxFile fileContent marker ".dll"
 
     [<Test>]
-    member public this.``Fsx.InvalidHashReference.ShouldBeASquiggle.Bug3012``() =  
-        let code = 
+    member public this.``Fsx.InvalidHashReference.ShouldBeASquiggle.Bug3012``() =
+        let code =
             ["#light"
              "#r \"Bar.dll\""]
         let (project, file) = createSingleFileFsxFromLines code
-        MoveCursorToEndOfMarker(file,"#r \"Ba") 
+        MoveCursorToEndOfMarker(file,"#r \"Ba")
         let squiggle = GetSquiggleAtCursor(file)
         TakeCoffeeBreak(this.VS)
         Assert.IsTrue(snd squiggle.Value |> fun str -> str.Contains("Bar.dll"))
@@ -984,63 +984,63 @@ type UsingMSBuild() as this =
     // Bug seen during development: The unresolved reference error would x-ray through to the root.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ScriptClosure.TransitiveLoad14``() =  
+    member public this.``Fsx.ScriptClosure.TransitiveLoad14``() =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
-        let project = CreateProject(solution,"testproject")    
+        let project = CreateProject(solution,"testproject")
         let script2 = AddFileFromText(project,"Script2.fsx",
                                       ["#load \"Script1.fsx\""
                                        "#r \"NonExisting\""
-                                       ])      
+                                       ])
         let script1 = AddFileFromText(project,"Script1.fsx",
                                       ["#load \"Script2.fsx\""
                                        "#r \"System\""
-                                       ])                                                   
+                                       ])
 
-        let script1 = OpenFile(project,"Script1.fsx")   
-        TakeCoffeeBreak(this.VS)      
-        MoveCursorToEndOfMarker(script1,"#r \"Sys") 
+        let script1 = OpenFile(project,"Script1.fsx")
+        TakeCoffeeBreak(this.VS)
+        MoveCursorToEndOfMarker(script1,"#r \"Sys")
         AssertEqual(None,GetSquiggleAtCursor(script1))
-    
-    member private this.TestFsxHashDirectivesAreErrors(mark : string, expectedStr : string) = 
-        let code = 
+
+    member private this.TestFsxHashDirectivesAreErrors(mark : string, expectedStr : string) =
+        let code =
                                     ["#light"
                                      "#r \"JoeBob\""
                                      "#I \".\""
                                      "#load \"Dooby\""
                                      ]
         let (_, _, file) = this.CreateSingleFileProject(code)
-        MoveCursorToEndOfMarker(file,mark) 
+        MoveCursorToEndOfMarker(file,mark)
         let ans = GetSquiggleAtCursor(file)
         match ans with
-        | Some(sev,msg) -> 
+        | Some(sev,msg) ->
             AssertEqual(Microsoft.VisualStudio.FSharp.LanguageService.Severity.Error,sev)
             AssertContains(msg,expectedStr)
-        | _ -> Assert.Fail() 
+        | _ -> Assert.Fail()
 
     /// FEATURE: #r, #I, #load are all errors when running under the language service
     [<Test>]
-    member public this.``Fsx.HashDirectivesAreErrors.InNonScriptFiles.Case1``() =  
+    member public this.``Fsx.HashDirectivesAreErrors.InNonScriptFiles.Case1``() =
         this.TestFsxHashDirectivesAreErrors("#r \"Joe","#r")
-     
+
     [<Test>]
-    member public this.``Fsx.HashDirectivesAreErrors.InNonScriptFiles.Case2``() =  
-        this.TestFsxHashDirectivesAreErrors("#I \"","#I")      
-        
+    member public this.``Fsx.HashDirectivesAreErrors.InNonScriptFiles.Case2``() =
+        this.TestFsxHashDirectivesAreErrors("#I \"","#I")
+
     [<Test>]
-    member public this.``Fsx.HashDirectivesAreErrors.InNonScriptFiles.Case3``() =  
-        this.TestFsxHashDirectivesAreErrors("#load \"Doo","may only be used in F# script files")      
+    member public this.``Fsx.HashDirectivesAreErrors.InNonScriptFiles.Case3``() =
+        this.TestFsxHashDirectivesAreErrors("#load \"Doo","may only be used in F# script files")
 
     /// FEATURE: #reference against a non-assembly .EXE gives a reasonable error message
     //[<Test>]
-    member public this.``Fsx.HashReferenceAgainstNonAssemblyExe``() = 
+    member public this.``Fsx.HashReferenceAgainstNonAssemblyExe``() =
         let windows = System.Environment.GetEnvironmentVariable("windir")
         let code =
                                     ["#light"
                                      sprintf "#reference @\"%s\"" (Path.Combine(windows,"notepad.exe"))
                                      "    let x = 1"]
         let (_, file) = createSingleFileFsxFromLines code
-        
+
         MoveCursorToEndOfMarker(file,"#refe")
         let ans = GetSquiggleAtCursor(file)
         AssertSquiggleIsErrorContaining(ans, "was not found or is invalid")
@@ -1054,10 +1054,10 @@ type UsingMSBuild() as this =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
-        
-        let file1 = AddFileFromText(project,"File1.fs", 
+
+        let file1 = AddFileFromText(project,"File1.fs",
                                     ["#light"
-                                     "module File1" 
+                                     "module File1"
                                      "DogChow" // <-- error
                                     ])
 
@@ -1066,13 +1066,13 @@ type UsingMSBuild() as this =
                                      "#load @\"File1.fs\""
                                      ])
         let file2 = OpenFile(project,"File2.fsx")
-        
+
         MoveCursorToEndOfMarker(file2,"#load @\"Fi")
-        TakeCoffeeBreak(this.VS)        
-        let ans = GetSquiggleAtCursor(file2)    
-        AssertSquiggleIsErrorContaining(ans, "DogChow")      
-        
-        
+        TakeCoffeeBreak(this.VS)
+        let ans = GetSquiggleAtCursor(file2)
+        AssertSquiggleIsErrorContaining(ans, "DogChow")
+
+
      // FEATURE: A #loaded file is squiggled with a warning if there are warning that file.
     [<Test>]
     [<Category("fsx closure")>]
@@ -1080,8 +1080,8 @@ type UsingMSBuild() as this =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
-        
-        let file1 = AddFileFromText(project,"File1.fs", 
+
+        let file1 = AddFileFromText(project,"File1.fs",
                                     ["module File1Module"
                                      "type WarningHere<'a> = static member X() = 0"
                                      "let y = WarningHere.X"
@@ -1092,10 +1092,10 @@ type UsingMSBuild() as this =
                                      "#load @\"File1.fs\""
                                      ])
         let file2 = OpenFile(project,"File2.fsx")
-        
+
         MoveCursorToEndOfMarker(file2,"#load @\"Fi")
         let ans = GetSquiggleAtCursor(file2)
-        AssertSquiggleIsWarningContaining(ans, "WarningHere")  
+        AssertSquiggleIsWarningContaining(ans, "WarningHere")
 
      // Bug: #load should report the first error message from a file
     [<Test>]
@@ -1104,10 +1104,10 @@ type UsingMSBuild() as this =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
-        
-        let file1 = AddFileFromText(project,"File1.fs", 
+
+        let file1 = AddFileFromText(project,"File1.fs",
                                     [ "#light"
-                                      "module File1" 
+                                      "module File1"
                                       "let a = 1 + \"\""
                                       "let c = new obj()"
                                       "let b = c.foo()"
@@ -1117,7 +1117,7 @@ type UsingMSBuild() as this =
                                      "#load @\"File1.fs\""
                                      ])
         let file2 = OpenFile(project,"File2.fsx")
-       
+
         MoveCursorToEndOfMarker(file2,"#load @\"Fi")
         let ans = GetSquiggleAtCursor(file2)
         AssertSquiggleIsErrorContaining(ans, "'string'")
@@ -1130,7 +1130,7 @@ type UsingMSBuild() as this =
         use _guard = this.UsingNewVS()
         let stopWatch = new System.Diagnostics.Stopwatch()
         let ResetStopWatch() = stopWatch.Reset(); stopWatch.Start()
-        let time1 op a message = 
+        let time1 op a message =
             ResetStopWatch()
             let result = op a
             printf "%s %d ms\n" message stopWatch.ElapsedMilliseconds
@@ -1141,23 +1141,23 @@ type UsingMSBuild() as this =
         let projectOutput = time1 Build project "Time to build project"
         printfn "Output of building project was %s" projectOutput.ExecutableOutput
         printfn "Project directory is %s" (ProjectDirectory project)
-        
+
         let file2 = AddFileFromText(project,"File2.fsx",
                                     ["#light"
                                      "#reference @\"bin\\Debug\\testproject.exe\""
                                      ])
         let file2 = OpenFile(project,"File2.fsx")
-        
+
         MoveCursorToEndOfMarker(file2,"#reference @\"bin\\De")
         let ans = GetSquiggleAtCursor(file2)
         AssertNoSquiggle(ans)
 
-               
+
 
     /// In this bug, multiple references to mscorlib .dll were causing problem in load closure
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.BugAllowExplicitReferenceToMsCorlib``() =  
+    member public this.``Fsx.BugAllowExplicitReferenceToMsCorlib``() =
         let code =
                                     ["#r \"mscorlib\""
                                      "fsi."
@@ -1166,13 +1166,13 @@ type UsingMSBuild() as this =
         MoveCursorToEndOfMarker(file,"fsi.")
         TakeCoffeeBreak(this.VS)
         let completions = AutoCompleteAtCursor file
-        AssertCompListContains(completions,"CommandLineArgs")        
-        
-    /// FEATURE: There is a global fsi module that should be in scope for script files.        
+        AssertCompListContains(completions,"CommandLineArgs")
+
+    /// FEATURE: There is a global fsi module that should be in scope for script files.
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.Bug2530FsiObject``() =  
-        let code = 
+    member public this.``Fsx.Bug2530FsiObject``() =
+        let code =
                                     ["#light"
                                      "fsi."
                                      ]
@@ -1181,12 +1181,12 @@ type UsingMSBuild() as this =
         TakeCoffeeBreak(this.VS)
         let completions = AutoCompleteAtCursor file
         AssertCompListContains(completions,"CommandLineArgs")
-  
+
     // Ensure that the script closure algorithm gets the right order of hash directives
     [<Test>]
     [<Category("fsx closure")>]
-    member public this.``Fsx.ScriptClosure.SurfaceOrderOfHashes``() =  
-        let code = 
+    member public this.``Fsx.ScriptClosure.SurfaceOrderOfHashes``() =
+        let code =
                                     ["#r \"System.Runtime.Remoting\""
                                      "#r \"System.Transactions\""
                                      "#load \"Load1.fs\""
@@ -1205,21 +1205,21 @@ type UsingMSBuild() as this =
 
     /// FEATURE: #reference against a strong name should work.
     [<Test>]
-    member public this.``Fsx.HashReferenceAgainstStrongName``() = 
+    member public this.``Fsx.HashReferenceAgainstStrongName``() =
         let code =
                                             ["#light"
                                              sprintf "#reference \"System.Core, Version=%s, Culture=neutral, PublicKeyToken=b77a5c561934e089\"" (System.Environment.Version.ToString())
                                              "open System."]
         let (_, file) = createSingleFileFsxFromLines code
-        MoveCursorToEndOfMarker(file,"open System.") 
+        MoveCursorToEndOfMarker(file,"open System.")
         let completions = AutoCompleteAtCursor file
-        AssertCompListContains(completions,"Linq")   
+        AssertCompListContains(completions,"Linq")
 
 
     /// Try out some bogus file names in #r, #I and #load.
     [<Test>]
     member public this.``Fsx.InvalidMetaCommandFilenames``() =
-        let code = 
+        let code =
                                     [
                                      "#r @\"\""
                                      "#load @\"\""
@@ -1246,9 +1246,9 @@ type UsingMSBuild() as this =
                                     ]
         let (_, file) = createSingleFileFsxFromLines code
         MoveCursorToEndOfMarker(file,"let xy")
-        AssertEqual(TokenType.Identifier ,GetTokenTypeAtCursor(file))  
+        AssertEqual(TokenType.Identifier ,GetTokenTypeAtCursor(file))
 
-    // Ensure that basic compile of an .fsx works        
+    // Ensure that basic compile of an .fsx works
     [<Test>]
     [<Category("fsx closure")>]
     [<Category("fsx compile")>]
@@ -1256,15 +1256,15 @@ type UsingMSBuild() as this =
         use _guard = this.UsingNewVS()
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
-        
+
         let file1 = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,
                                       ["printfn \"Hello world\""])
         let build = time1 Build project "Time to build project"
         Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
         ShowErrors(project)
-        
 
-    // Compile a script which #loads a source file. The build can't succeed without the loaded file.      
+
+    // Compile a script which #loads a source file. The build can't succeed without the loaded file.
     [<Test; Category("Expensive")>]
     [<Category("fsx closure")>]
     [<Category("fsx compile")>]
@@ -1281,13 +1281,13 @@ type UsingMSBuild() as this =
                                       ["#load \"File.fs\""
                                        "printfn \"%d\" Namespace.Module.Value"])
         let build = time1 Build project "Time to build project"
-        if SupportsOutputWindowPane(this.VS) then 
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
             ()
         Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
-        
-    // Compile a script which #loads a source file. The build can't succeed without 
+
+    // Compile a script which #loads a source file. The build can't succeed without
     [<Test; Category("Expensive")>]
     [<Category("fsx closure")>]
     [<Category("fsx compile")>]
@@ -1303,13 +1303,13 @@ type UsingMSBuild() as this =
         let fsx = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,
                                       ["#load \"File.fs\""
                                        "printfn \"%d\" Namespace.Module.Value"])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
             ()
-        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")        
-        
+        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
+
     // Must be explicitly referenced by compile.
     [<Test>]
     [<Category("fsx closure")>]
@@ -1320,13 +1320,13 @@ type UsingMSBuild() as this =
         let project = CreateProject(solution,"testproject")
         let fsx = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,
                                       ["let x = fsi.CommandLineArgs"])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
             ()
-        Assert.IsTrue(not(build.BuildSucceeded), "Expected build to fail")    
-        
+        Assert.IsTrue(not(build.BuildSucceeded), "Expected build to fail")
+
     // Must be explicitly referenced by compile.
     [<Test>]
     [<Category("fsx closure")>]
@@ -1350,16 +1350,16 @@ type UsingMSBuild() as this =
 
         let fsx = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,
                                       ["let x = fsi.CommandLineArgs"])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
             ()
-        if not(SupportsOutputWindowPane(this.VS)) then  
-            Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")                
-        
-        
-    // Ensure that #load order is preserved when #loading multiple files. 
+        if not(SupportsOutputWindowPane(this.VS)) then
+            Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
+
+
+    // Ensure that #load order is preserved when #loading multiple files.
     [<Test>]
     [<Category("fsx closure")>]
     [<Category("fsx compile")>]
@@ -1376,20 +1376,20 @@ type UsingMSBuild() as this =
                                       ["namespace Namespace"
                                        "module Module2 ="
                                        "  let Value = Module1.Value"
-                                      ])                                      
+                                      ])
         let fsx = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,
                                       [
                                        "#load \"File1.fs\""
                                        "#load \"File2.fs\""
                                        "printfn \"%d\" Namespace.Module2.Value"])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
             ()
-        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")          
-        
-    // If an fs file is explicitly passed in to the compiler and also #loaded then 
+        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
+
+    // If an fs file is explicitly passed in to the compiler and also #loaded then
     // the command-line order is respected rather than the #load order
     [<Test>]
     [<Category("fsx closure")>]
@@ -1407,21 +1407,21 @@ type UsingMSBuild() as this =
                                       ["namespace Namespace"
                                        "module Module2 ="
                                        "  let Value = Module1.Value"
-                                      ])                                      
+                                      ])
         let fsx = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,
                                       [
                                        "#load \"File2.fs\"" // Wrong order
                                        "#load \"File1.fs\""
                                        "printfn \"%d\" Namespace.Module2.Value"])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
             ()
-        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed") 
+        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
+
+
 
-        
-        
     // If a #loaded file does not exist, there should be an error
     [<Test>]
     [<Category("fsx closure")>]
@@ -1434,15 +1434,15 @@ type UsingMSBuild() as this =
                                       [
                                        "#load \"NonexistentFile.fs\""
                                        ])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
-            AssertListContainsInOrder(lines, ["error FS0079: Could not load file"; "NonexistentFile.fs"; "because it does not exist or is inaccessible"])            
-            
-        Assert.IsTrue(not(build.BuildSucceeded), "Expected build to fail")       
-        
-        
+            AssertListContainsInOrder(lines, ["error FS0079: Could not load file"; "NonexistentFile.fs"; "because it does not exist or is inaccessible"])
+
+        Assert.IsTrue(not(build.BuildSucceeded), "Expected build to fail")
+
+
     // #r references should be respected.
     [<Test>]
     [<Category("fsx closure")>]
@@ -1456,14 +1456,14 @@ type UsingMSBuild() as this =
                                        "#r \"System.Messaging\""
                                        "let a = new System.Messaging.AccessControlEntry()"
                                        ])
-        let build = time1 Build project "Time to build project" 
-        if SupportsOutputWindowPane(this.VS) then 
+        let build = time1 Build project "Time to build project"
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
             for line in lines do printfn "%s" line
-            
-        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")          
-        
-        
+
+        Assert.IsTrue(build.BuildSucceeded, "Expected build to succeed")
+
+
     // Missing script file should be a reasonable failure, not a callstack.
     [<Test>]
     [<Category("fsx closure")>]
@@ -1473,24 +1473,24 @@ type UsingMSBuild() as this =
         let solution = this.CreateSolution()
         let project = CreateProject(solution,"testproject")
         let fsx = AddFileFromTextEx(project,"Script.fsx","Script.fsx",BuildAction.Compile,[])
-        DeleteFileFromDisk(this.VS, fsx) 
-        
+        DeleteFileFromDisk(this.VS, fsx)
+
         let build = Build project
-        if SupportsOutputWindowPane(this.VS) then 
+        if SupportsOutputWindowPane(this.VS) then
             let lines = GetOutputWindowPaneLines(this.VS)
-            AssertListContainsInOrder(lines, 
+            AssertListContainsInOrder(lines,
                                       ["Could not find file "
-                                       "Script.fsx"])           
-            for line in lines do 
+                                       "Script.fsx"])
+            for line in lines do
                 printfn "%s" line
                 AssertNotContains(line,"error MSB") // Microsoft.FSharp.Targets(135,9): error MSB6006: "fsc.exe" exited with code -532462766.
 
-        Assert.IsTrue(not(build.BuildSucceeded), "Expected build to fail")                                  
-        
-        
+        Assert.IsTrue(not(build.BuildSucceeded), "Expected build to fail")
+
+
     /// There was a problem in which synthetic tokens like #load were causing asserts
     [<Test; Category("Expensive")>]
-    member public this.``Fsx.SyntheticTokens``() =     
+    member public this.``Fsx.SyntheticTokens``() =
         Helper.ExhaustivelyScrutinize(
             this.TestRunner,
               ["#light"
@@ -1498,49 +1498,49 @@ type UsingMSBuild() as this =
                "#reference \"\""
                "#load \"\""
                "#line 52"
-               "#nowarn 72"]        
+               "#nowarn 72"]
             )
-                                 
+
     /// There was a problem where an unclosed reference picked up the text of the reference on the next line.
     [<Test>]
-    member public this.``Fsx.ShouldBeAbleToReference30Assemblies.Bug2050``() =     
-        let code = 
+    member public this.``Fsx.ShouldBeAbleToReference30Assemblies.Bug2050``() =
+        let code =
                                     ["#light"
                                      "#r \"System.Core.dll\""
                                      "open System."
                                      ]
         let (_, file) = createSingleFileFsxFromLines code
-        MoveCursorToEndOfMarker(file,"open System.") 
+        MoveCursorToEndOfMarker(file,"open System.")
         let completions = AutoCompleteAtCursor file
         AssertCompListContains(completions,"Linq")
 
     /// There was a problem where an unclosed reference picked up the text of the reference on the next line.
     [<Test>]
-    member public this.``Fsx.UnclosedHashReference.Case1``() =     
+    member public this.``Fsx.UnclosedHashReference.Case1``() =
         Helper.ExhaustivelyScrutinize(
             this.TestRunner,
            ["#light"
             "#reference \"" // Unclosed
-            "#reference \"Hello There\""]    
+            "#reference \"Hello There\""]
             )
     [<Test>]
-    member public this.``Fsx.UnclosedHashReference.Case2``() =     
+    member public this.``Fsx.UnclosedHashReference.Case2``() =
         Helper.ExhaustivelyScrutinize(
             this.TestRunner,
           ["#light"
            "#r \"" // Unclosed
-           "# \"Hello There\""]                                            
+           "# \"Hello There\""]
            )
-                                     
+
     /// There was a problem where an unclosed reference picked up the text of the reference on the next line.
     [<Test>]
-    member public this.``Fsx.UnclosedHashLoad``() =     
+    member public this.``Fsx.UnclosedHashLoad``() =
         Helper.ExhaustivelyScrutinize(
-            this.TestRunner, 
+            this.TestRunner,
             [ "#light"
               "#load \"" // Unclosed
               "#load \"Hello There\""]
-            ) 
+            )
 
     [<Test>]
     [<Category("TypeProvider")>]
@@ -1551,7 +1551,7 @@ type UsingMSBuild() as this =
                                      "let x2 : int = N1.T1().MethodWithErasedCodeUsingConditional()"
                                      "let x3 : int = N1.T1().MethodWithErasedCodeUsingTypeAs()"
                                      ]
-        let refs = 
+        let refs =
             [
                 PathRelativeToTestAssembly(@"DummyProviderForLanguageServiceTesting.dll")
             ]
@@ -1586,7 +1586,7 @@ type UsingMSBuild() as this =
         let totalInvaldiationHandlersAdded() = totalInvaldiationHandlersAddedMeth.Invoke(null, [| |]) :?> int
         let totalInvaldiationHandlersRemoved() = totalInvaldiationHandlersRemovedMeth.Invoke(null, [| |]) :?> int
 
-         
+
         let startCreations = totalCreations()
         let startDisposals = totalDisposals()
         let startInvaldiationHandlersAdded = totalInvaldiationHandlersAdded()
@@ -1598,12 +1598,12 @@ type UsingMSBuild() as this =
 
         Assert.IsTrue(startCreations >= startDisposals, "Check0")
         Assert.IsTrue(startInvaldiationHandlersAdded >= startInvaldiationHandlersRemoved, "Check0")
-        for i in 1 .. 50 do 
+        for i in 1 .. 50 do
             let solution = this.CreateSolution()
-            let project = CreateProject(solution,"testproject" + string (i % 20))    
+            let project = CreateProject(solution,"testproject" + string (i % 20))
             this.AddAssemblyReference(project, PathRelativeToTestAssembly(@"DummyProviderForLanguageServiceTesting.dll"))
             let fileName = sprintf "File%d.fs" i
-            let file1 = AddFileFromText(project,fileName, ["let x" + string i + " = N1.T1()" ])    
+            let file1 = AddFileFromText(project,fileName, ["let x" + string i + " = N1.T1()" ])
             let file = OpenFile(project,fileName)
             TakeCoffeeBreak(this.VS)
             AssertNoErrorsOrWarnings project   // ...and not an error on the first line.
@@ -1615,9 +1615,9 @@ type UsingMSBuild() as this =
             ignore (GetF1KeywordAtCursor file)
             let parmInfo = GetParameterInfoAtCursor file
 
-            let file1 = OpenFile(project,fileName)   
+            let file1 = OpenFile(project,fileName)
 
-            // The disposals should be at least one less 
+            // The disposals should be at least one less
             let c = countCreations()
             let d = countDisposals()
 
@@ -1628,15 +1628,15 @@ type UsingMSBuild() as this =
             // even after we've moved on from it.
             Assert.IsTrue((c >= i), "Check3, countCreations() >= i, iteration " + string i + ", countCreations() = " + string c)
 
-            if not clearing then 
+            if not clearing then
                 // By default we hold 3 build incrementalBuilderCache entries and 5 typeCheckInfo entries, so if we're not clearing
                 // there should be some roots to project builds still present
-                if i >= 3 then 
+                if i >= 3 then
                     Assert.IsTrue(c >= d + 3, "Check4a, c >= countDisposals() + 3, iteration " + string i + ", i = " + string i + ", countDisposals() = " + string d)
                     printfn "Check4a2, i = %d, countInvaldiationHandlersRemoved() = %d" i (countInvaldiationHandlersRemoved())
 
             // If we forcefully clear out caches and force a collection, then we can say much stronger things...
-            if clearing then 
+            if clearing then
                 ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients(this.VS)
                 let c = countCreations()
                 let d = countDisposals()
@@ -1644,7 +1644,7 @@ type UsingMSBuild() as this =
                 // Creations should be equal to disposals after a `ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients`
                 Assert.IsTrue((c = d), "Check4b, countCreations() = countDisposals(), iteration " + string i)
                 Assert.IsTrue((countInvaldiationHandlersAdded() = countInvaldiationHandlersRemoved()), "Check4b2, all invlidation handlers removed, iteration " + string i)
-        
+
         let c = countCreations()
         let d = countDisposals()
         Assert.IsTrue(c >= 50, "Check5, at end, countCreations() >= 50")
@@ -1666,7 +1666,7 @@ type UsingMSBuild() as this =
 
 
 // Context project system
-[<TestFixture>] 
-type UsingProjectSystem() = 
+[<TestFixture>]
+type UsingProjectSystem() =
     inherit UsingMSBuild(VsOpts = LanguageServiceExtension.ProjectSystemTestFlavour)
 
diff --git a/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj b/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj
index d4a67482ad2..a11b8d67fd1 100644
--- a/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj
+++ b/vsintegration/tests/UnitTests/VisualFSharp.UnitTests.fsproj
@@ -6,7 +6,7 @@
     <TargetFramework>net472</TargetFramework>
     <PlatformTarget>x86</PlatformTarget>
     <OutputType>Library</OutputType>
-    <NoWarn>$(NoWarn);44;58;75;3005</NoWarn>
+    <NoWarn>$(NoWarn);44;58;75;3005;1182</NoWarn>
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <UsePackageTargetFallbackHack>true</UsePackageTargetFallbackHack>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>