Merge master to release/dev16.8

.gitignore

@@ -53,6 +53,7 @@ scripts/*.patch
 /src/fsharp/FSharp.LanguageService.Compiler/pplex.fs
 /src/fsharp/FSharp.LanguageService.Compiler/pppars.fs
 /src/fsharp/FSharp.LanguageService.Compiler/pppars.fsi
+/src/fsharp/*/Properties/launchSettings.json
 /vsintegration/src/unittests/Unittests.fsi
 /tests/*FSharp_Failures.env
 /tests/*FSharp_Failures.lst

src/fsharp/AccessibilityLogic.fs

@@ -249,12 +249,53 @@ let private IsILMethInfoAccessible g amap m adType ad ilminfo =
 let GetILAccessOfILPropInfo (ILPropInfo(tinfo, pdef)) =
     let tdef = tinfo.RawMetadata
     let ilAccess =
-        match pdef.GetMethod with 
-        | Some mref -> (resolveILMethodRef tdef mref).Access 
-        | None -> 
-            match pdef.SetMethod with 
-            | None -> ILMemberAccess.Public
-            | Some mref -> (resolveILMethodRef tdef mref).Access
+        match pdef.GetMethod, pdef.SetMethod with 
+        | Some mref, None 
+        | None, Some mref -> (resolveILMethodRef tdef mref).Access
+
+        | Some mrefGet, Some mrefSet ->
+            //
+            // Dotnet properties have a getter and a setter method, each of which can have a separate visibility public, protected, private etc ...
+            // This code computes the visibility for the property by choosing the most visible method. This approximation is usefull for cases
+            // where the compiler needs to know the visibility of the property.
+            // The specific ordering for choosing the most visible is:
+            //  ILMemberAccess.Public,
+            //  ILMemberAccess.FamilyOrAssembly
+            //  ILMemberAccess.Assembly
+            //  ILMemberAccess.Family
+            //  ILMemberAccess.FamilyAndAssembly
+            //  ILMemberAccess.Private
+            //  ILMemberAccess.CompilerControlled
+            //          
+            let getA = (resolveILMethodRef tdef mrefGet).Access
+            let setA = (resolveILMethodRef tdef mrefSet).Access
+
+            // Use the accessors to determine the visibility of the property.
+            // N.B. It is critical to keep the ordering in decreasing visibility order in the following match expression
+            match getA, setA with
+            | ILMemberAccess.Public, _
+            | _, ILMemberAccess.Public -> ILMemberAccess.Public
+
+            | ILMemberAccess.FamilyOrAssembly, _
+            | _, ILMemberAccess.FamilyOrAssembly -> ILMemberAccess.FamilyOrAssembly
+
+            | ILMemberAccess.Assembly, _
+            | _, ILMemberAccess.Assembly -> ILMemberAccess.Assembly
+
+            | ILMemberAccess.Family, _
+            | _, ILMemberAccess.Family -> ILMemberAccess.Family
+
+            | ILMemberAccess.FamilyAndAssembly, _
+            | _, ILMemberAccess.FamilyAndAssembly -> ILMemberAccess.FamilyAndAssembly
+
+            | ILMemberAccess.Private, _
+            | _, ILMemberAccess.Private -> ILMemberAccess.Private
+
+            | ILMemberAccess.CompilerControlled, _
+            | _, ILMemberAccess.CompilerControlled -> ILMemberAccess.CompilerControlled
+
+        | None, None -> ILMemberAccess.Public
+
     ilAccess
 
 let IsILPropInfoAccessible g amap m ad pinfo =
@@ -323,8 +364,11 @@ let IsMethInfoAccessible amap m ad minfo = IsTypeAndMethInfoAccessible amap m ad
 
 let IsPropInfoAccessible g amap m ad = function 
     | ILProp ilpinfo -> IsILPropInfoAccessible g amap m ad ilpinfo
-    | FSProp (_, _, Some vref, _) 
-    | FSProp (_, _, _, Some vref) -> IsValAccessible ad vref
+    | FSProp (_, _, Some vref, None) 
+    | FSProp (_, _, None, Some vref) -> IsValAccessible ad vref
+    | FSProp (_, _, Some vrefGet, Some vrefSet) -> 
+        // pick most accessible
+        IsValAccessible ad vrefGet || IsValAccessible ad vrefSet
 #if !NO_EXTENSIONTYPING
     | ProvidedProp (amap, tppi, m) as pp-> 
         let access = 
@@ -343,4 +387,3 @@ let IsPropInfoAccessible g amap m ad = function
 
 let IsFieldInfoAccessible ad (rfref:RecdFieldInfo) =
     IsAccessible ad rfref.RecdField.Accessibility
-

src/fsharp/ErrorLogger.fs

@@ -677,15 +677,24 @@ type public FSharpErrorSeverityOptions =
 // let dummyMethodFOrBug6417A() = () 
 // let dummyMethodFOrBug6417B() = () 
 
-let private tryLanguageFeatureErrorAux (langVersion: LanguageVersion) (langFeature: LanguageFeature) (m: range) error =
-    if not (langVersion.SupportsFeature langFeature) then 
+let private tryLanguageFeatureErrorAux (langVersion: LanguageVersion) (langFeature: LanguageFeature) (m: range) =
+    if not (langVersion.SupportsFeature langFeature) then
         let featureStr = langVersion.GetFeatureString langFeature
         let currentVersionStr = langVersion.SpecifiedVersionString
         let suggestedVersionStr = langVersion.GetFeatureVersionString langFeature
-        error (Error(FSComp.SR.chkFeatureNotLanguageSupported(featureStr, currentVersionStr, suggestedVersionStr), m))
+        Some (Error(FSComp.SR.chkFeatureNotLanguageSupported(featureStr, currentVersionStr, suggestedVersionStr), m))
+    else
+        None
 
 let internal tryLanguageFeatureError langVersion langFeature m =
-    tryLanguageFeatureErrorAux langVersion langFeature m error
+    match tryLanguageFeatureErrorAux langVersion langFeature m with
+    | Some e -> error (e)
+    | None -> ()
 
 let internal tryLanguageFeatureErrorRecover langVersion langFeature m =
-    tryLanguageFeatureErrorAux langVersion langFeature m errorR
+    match tryLanguageFeatureErrorAux langVersion langFeature m with
+    | Some e -> errorR e
+    | None -> ()
+
+let internal tryLanguageFeatureErrorOption langVersion langFeature m =
+    tryLanguageFeatureErrorAux langVersion langFeature m 

src/fsharp/FSComp.txt

@@ -1512,4 +1512,8 @@ featureFixedIndexSlice3d4d,"fixed-index slice 3d/4d"
 featureAndBang,"applicative computation expressions"
 featureNullableOptionalInterop,"nullable optional interop"
 featureDefaultInterfaceMemberConsumption,"default interface member consumption"
-featureWitnessPassing,"witness passing"
+featureWitnessPassing,"witness passing for trait constraints in F# quotations"
+3353,fsiInvalidDirective,"Invalid directive '#%s %s'"
+3360,typrelInterfaceWithConcreteAndVariable,"'%s' cannot implement the interface '%s' with the two instantiations '%s' and '%s' because they may unify."
+3361,typrelInterfaceWithConcreteAndVariableObjectExpression,"You cannot implement the interface '%s' with the two instantiations '%s' and '%s' because they may unify."
+featureInterfacesWithMultipleGenericInstantiation,"interfaces with multiple generic instantiation"

src/fsharp/FSharp.Core/string.fs

@@ -12,6 +12,11 @@ namespace Microsoft.FSharp.Core
     [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
     [<RequireQualifiedAccess>]
     module String =
+        [<Literal>]
+        /// LOH threshold is calculated from FSharp.Compiler.AbstractIL.Internal.Library.LOH_SIZE_THRESHOLD_BYTES,
+        /// and is equal to 80_000 / sizeof<char>
+        let LOH_CHAR_THRESHOLD = 40_000
+
         [<CompiledName("Length")>]
         let length (str:string) = if isNull str then 0 else str.Length
 
@@ -37,9 +42,13 @@ namespace Microsoft.FSharp.Core
             if String.IsNullOrEmpty str then
                 String.Empty
             else
-                let res = StringBuilder str.Length
-                str |> iter (fun c -> res.Append(mapping c) |> ignore)
-                res.ToString()
+                let result = str.ToCharArray()
+                let mutable i = 0
+                for c in result do
+                    result.[i] <- mapping c
+                    i <- i + 1
+
+                new String(result)
 
         [<CompiledName("MapIndexed")>]
         let mapi (mapping: int -> char -> char) (str:string) =
@@ -53,13 +62,30 @@ namespace Microsoft.FSharp.Core
 
         [<CompiledName("Filter")>]
         let filter (predicate: char -> bool) (str:string) =
-            if String.IsNullOrEmpty str then
+            let len = length str
+
+            if len = 0 then 
                 String.Empty
-            else
-                let res = StringBuilder str.Length
+
+            elif len > LOH_CHAR_THRESHOLD then
+                // By using SB here, which is twice slower than the optimized path, we prevent LOH allocations 
+                // and 'stop the world' collections if the filtering results in smaller strings.
+                // We also don't pre-allocate SB here, to allow for less mem pressure when filter result is small.
+                let res = StringBuilder()
                 str |> iter (fun c -> if predicate c then res.Append c |> ignore)
                 res.ToString()
 
+            else
+                // Must do it this way, since array.fs is not yet in scope, but this is safe
+                let target = Microsoft.FSharp.Primitives.Basics.Array.zeroCreateUnchecked len
+                let mutable i = 0
+                for c in str do
+                    if predicate c then 
+                        target.[i] <- c
+                        i <- i + 1
+
+                String(target, 0, i)
+
         [<CompiledName("Collect")>]
         let collect (mapping: char -> string) (str:string) =
             if String.IsNullOrEmpty str then
@@ -81,13 +107,38 @@ namespace Microsoft.FSharp.Core
         let replicate (count:int) (str:string) =
             if count < 0 then invalidArgInputMustBeNonNegative "count" count
 
-            if String.IsNullOrEmpty str then
+            let len = length str
+            if len = 0 || count = 0 then 
                 String.Empty
+
+            elif len = 1 then
+                new String(str.[0], count)
+
+            elif count <= 4 then
+                match count with
+                | 1 -> str
+                | 2 -> String.Concat(str, str)
+                | 3 -> String.Concat(str, str, str)
+                | _ -> String.Concat(str, str, str, str)
+
             else
-                let res = StringBuilder(count * str.Length)
-                for i = 0 to count - 1 do 
-                   res.Append str |> ignore
-                res.ToString()
+                // Using the primitive, because array.fs is not yet in scope. It's safe: both len and count are positive.
+                let target = Microsoft.FSharp.Primitives.Basics.Array.zeroCreateUnchecked (len * count)
+                let source = str.ToCharArray()
+
+                // O(log(n)) performance loop:
+                // Copy first string, then keep copying what we already copied 
+                // (i.e., doubling it) until we reach or pass the halfway point
+                Array.Copy(source, 0, target, 0, len)
+                let mutable i = len
+                while i * 2 < target.Length do
+                    Array.Copy(target, 0, target, i, i)
+                    i <- i * 2
+
+                // finally, copy the remain half, or less-then half
+                Array.Copy(target, 0, target, i, target.Length - i)
+                new String(target)
+
 
         [<CompiledName("ForAll")>]
         let forall predicate (str:string) =

src/fsharp/FSharp.DependencyManager.Nuget/FSharp.DependencyManager.Utilities.fs

@@ -126,12 +126,12 @@ module internal Utilities =
             | value when not (String.IsNullOrEmpty(value)) ->
                 Some value                           // Value set externally
             | _ ->
-                // Probe for netsdk install
+                // Probe for netsdk install, dotnet. and dotnet.exe is a constant offset from the location of System.Int32
                 let dotnetLocation =
                     let dotnetApp =
                         let platform = Environment.OSVersion.Platform
                         if platform = PlatformID.Unix then "dotnet" else "dotnet.exe"
-                    let assemblyLocation = typeof<DependencyManagerAttribute>.GetTypeInfo().Assembly.Location
+                    let assemblyLocation = typeof<Int32>.GetTypeInfo().Assembly.Location
                     Path.Combine(assemblyLocation, "../../..", dotnetApp)
 
                 if File.Exists(dotnetLocation) then

src/fsharp/IlxGen.fs

@@ -4298,8 +4298,10 @@ and GenActualSlotsig m cenv eenv (TSlotSig(_, ty, ctps, mtps, ilSlotParams, ilSl
 
 and GenNameOfOverridingMethod cenv (useMethodImpl, slotsig) =
     let (TSlotSig(nameOfOverridenMethod, enclTypOfOverridenMethod, _, _, _, _)) = slotsig
-    if useMethodImpl then qualifiedMangledNameOfTyconRef (tcrefOfAppTy cenv.g enclTypOfOverridenMethod) nameOfOverridenMethod
-    else nameOfOverridenMethod
+    if useMethodImpl then
+        qualifiedInterfaceImplementationName cenv.g enclTypOfOverridenMethod nameOfOverridenMethod
+    else
+        nameOfOverridenMethod
 
 and GenMethodImpl cenv eenv (useMethodImpl, (TSlotSig(nameOfOverridenMethod, _, _, _, _, _) as slotsig)) m =
     let ilOverrideTy, ilOverrideParams, ilOverrideRet = GenFormalSlotsig m cenv eenv slotsig

src/fsharp/LanguageFeatures.fs

@@ -32,6 +32,7 @@ type LanguageFeature =
     | NullableOptionalInterop
     | DefaultInterfaceMemberConsumption
     | WitnessPassing
+    | InterfacesWithMultipleGenericInstantiation
 
 /// LanguageVersion management
 type LanguageVersion (specifiedVersionAsString) =
@@ -41,12 +42,12 @@ type LanguageVersion (specifiedVersionAsString) =
     static let languageVersion47 = 4.7m
     static let languageVersion50 = 5.0m
     static let previewVersion = 9999m                   // Language version when preview specified
-    static let defaultVersion = languageVersion50       // Language version when default specified
+    static let defaultVersion = languageVersion47       // Language version when default specified
     static let latestVersion = defaultVersion           // Language version when latest specified
     static let latestMajorVersion = languageVersion47   // Language version when latestmajor specified
 
     static let validOptions = [| "preview"; "default"; "latest"; "latestmajor" |]
-    static let languageVersions = set [| languageVersion46; languageVersion47; languageVersion50 |]
+    static let languageVersions = set [| languageVersion46; languageVersion47 ; languageVersion50 |]
 
     static let features =
         dict [
@@ -58,17 +59,18 @@ type LanguageVersion (specifiedVersionAsString) =
 
             // F# 5.0
             LanguageFeature.FixedIndexSlice3d4d, languageVersion50
-            LanguageFeature.FromEndSlicing, languageVersion50
             LanguageFeature.DotlessFloat32Literal, languageVersion50
+            LanguageFeature.AndBang, languageVersion50
+            LanguageFeature.NullableOptionalInterop, languageVersion50
+            LanguageFeature.DefaultInterfaceMemberConsumption, languageVersion50
 
             // F# preview
-            LanguageFeature.NameOf, previewVersion
+            LanguageFeature.FromEndSlicing, previewVersion
             LanguageFeature.OpenStaticClasses, previewVersion
             LanguageFeature.PackageManagement, previewVersion
-            LanguageFeature.AndBang, previewVersion
-            LanguageFeature.NullableOptionalInterop, previewVersion
-            LanguageFeature.DefaultInterfaceMemberConsumption, previewVersion
             LanguageFeature.WitnessPassing, previewVersion
+            LanguageFeature.InterfacesWithMultipleGenericInstantiation, previewVersion
+            LanguageFeature.NameOf, previewVersion
         ]
 
     let specified =
@@ -80,7 +82,7 @@ type LanguageVersion (specifiedVersionAsString) =
         | "latestmajor" -> latestMajorVersion
         | "4.6" -> languageVersion46
         | "4.7" -> languageVersion47
-(*      | "5.0" -> languageVersion50    *)
+        | "5.0" -> languageVersion50
         | _ -> 0m
 
     let versionToString v =
@@ -138,6 +140,7 @@ type LanguageVersion (specifiedVersionAsString) =
         | LanguageFeature.NullableOptionalInterop -> FSComp.SR.featureNullableOptionalInterop()
         | LanguageFeature.DefaultInterfaceMemberConsumption -> FSComp.SR.featureDefaultInterfaceMemberConsumption()
         | LanguageFeature.WitnessPassing -> FSComp.SR.featureWitnessPassing()
+        | LanguageFeature.InterfacesWithMultipleGenericInstantiation -> FSComp.SR.featureInterfacesWithMultipleGenericInstantiation()
 
     /// Get a version string associated with the given feature.
     member _.GetFeatureVersionString feature =

src/fsharp/LanguageFeatures.fsi

@@ -20,6 +20,7 @@ type LanguageFeature =
     | NullableOptionalInterop
     | DefaultInterfaceMemberConsumption
     | WitnessPassing
+    | InterfacesWithMultipleGenericInstantiation
 
 /// LanguageVersion management
 type LanguageVersion =

src/fsharp/LexFilter.fs

@@ -1242,7 +1242,7 @@ type LexFilterImpl (lightSyntaxStatus: LightSyntaxStatus, compilingFsLib, lexer,
         // a TYPE or MODULE. So the lexfilter helps out by looking ahead for these tokens and (1) closing expression contexts and (2) inserting extra 'coming soon' tokens
         // that the expression rules in the FsYacc parser can 'shift' to make progress parsing the incomplete expressions, without using the 'recover' action.
         let insertComingSoonTokens(keywordName, comingSoon, isHere) =
-            // compiling the source for FSharp.Core.dll uses crazy syntax like 
+            // compiling the source for FSharp.Core.dll uses unconventional syntax like
             //     (# "unbox.any !0" type ('T) x : 'T #)
             // where the type keyword is used inside an expression, so we must exempt FSharp.Core from some extra failed-parse-diagnostics-recovery-processing of the 'type' keyword
             let mutable effectsToDo = []

src/fsharp/MethodCalls.fs

@@ -1173,6 +1173,15 @@ let AdjustCallerArgForOptional tcFieldInit eCallerMemberName (infoReader: InfoRe
         if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m))
         assignedArg
 
+    // For non-nullable, non-optional arguments no conversion is needed.
+    // We return precisely the assignedArg.  This also covers the case where there
+    // can be a lingering permitted type mismatch between caller argument and called argument, 
+    // specifically caller can by `byref` and called `outref`.  No coercion is inserted in the
+    // expression tree in this case. 
+    | NotOptional when not (isNullableTy g calledArgTy) -> 
+        if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m))
+        assignedArg
+
     | _ ->
 
         let callerArgExpr2 = 
@@ -1183,7 +1192,7 @@ let AdjustCallerArgForOptional tcFieldInit eCallerMemberName (infoReader: InfoRe
                 if isNullableTy g calledArgTy then 
                     MakeNullableExprIfNeeded infoReader calledArgTy callerArgTy callerArgExpr m
                 else
-                    callerArgExpr
+                    failwith "unreachable" // see case above
 
             | CallerSide dfltVal -> 
                 let calledArgTy = calledArg.CalledArgumentType