Merge release/dev16.7 to release/dev16.8

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/FSComp.txt

@@ -1512,4 +1512,4 @@ 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"

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/LanguageFeatures.fs

@@ -58,17 +58,17 @@ 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.NameOf, previewVersion
         ]
 
     let specified =
@@ -80,7 +80,7 @@ type LanguageVersion (specifiedVersionAsString) =
         | "latestmajor" -> latestMajorVersion
         | "4.6" -> languageVersion46
         | "4.7" -> languageVersion47
-(*      | "5.0" -> languageVersion50    *)
+        | "5.0" -> languageVersion50
         | _ -> 0m
 
     let versionToString v =

src/fsharp/pars.fsy

@@ -2702,7 +2702,7 @@ localBinding:
         let mRhs = expr.Range 
         let optReturnType = $4 
         let bindingBuilder, mBindLhs = $3 
-        let localBindingRange = unionRanges (rhs2 parseState 3 5) mRhs
+        let localBindingRange = unionRanges (rhs2 parseState 1 5) mRhs
         let localBindingBuilder = 
           (fun attrs vis mLetKwd -> 
             let mWhole = unionRanges mLetKwd mRhs
@@ -2711,7 +2711,7 @@ localBinding:
         localBindingRange, localBindingBuilder }
 
   | opt_inline opt_mutable bindingPattern  opt_topReturnTypeWithTypeConstraints EQUALS  error
-      { let mWhole = rhs2 parseState 3 5 
+      { let mWhole = rhs2 parseState 1 5 
         let mRhs = rhs parseState 5
         let optReturnType = $4 
         let bindingBuilder, mBindLhs = $3 
@@ -2726,7 +2726,7 @@ localBinding:
   | opt_inline opt_mutable bindingPattern  opt_topReturnTypeWithTypeConstraints recover
       { if not $5 then reportParseErrorAt (rhs parseState 5) (FSComp.SR.parsUnexpectedEndOfFileDefinition())
         let optReturnType = $4 
-        let mWhole = match optReturnType with None -> rhs parseState 3 | Some _ -> rhs2 parseState 3 4
+        let mWhole = rhs2 parseState 1 (match optReturnType with None -> 3 | _ -> 4)
         let mRhs = mWhole.EndRange  // zero-width range at end of last good token
         let bindingBuilder, mBindLhs = $3 
         let localBindingBuilder =