Merge pull request #7419 from dotnet/merges/release/dev16.3-to-release/dev16.4

Merge release/dev16.3 to release/dev16.4

Author: dotnet-automerge-bot

src/fsharp/LanguageFeatures.fs

@@ -54,7 +54,7 @@ type LanguageVersion (specifiedVersion) =
         LanguageFeature.RelaxWhitespace, languageVersion47
         LanguageFeature.NameOf, previewVersion
         LanguageFeature.ImplicitYield, languageVersion47
-        LanguageFeature.OpenStaticClasses, languageVersion47
+        LanguageFeature.OpenStaticClasses, previewVersion
         |]
 
     let specified =

src/fsharp/NameResolution.fs

@@ -758,14 +758,14 @@ let AddUnionCases2 bulkAddMode (eUnqualifiedItems: UnqualifiedItems) (ucrefs: Un
             let item = Item.UnionCase(GeneralizeUnionCaseRef ucref, false)
             acc.Add (ucref.CaseName, item))
 
-let AddStaticContentOfTyconRefToNameEnv (g:TcGlobals) (amap: Import.ImportMap) m (nenv: NameResolutionEnv)  (tcref:TyconRef) =
+let AddStaticContentOfTyconRefToNameEnv (g:TcGlobals) (amap: Import.ImportMap) ad m (nenv: NameResolutionEnv) (tcref:TyconRef) =
     // If OpenStaticClasses is not enabled then don't do this
     if amap.g.langVersion.SupportsFeature LanguageFeature.OpenStaticClasses then
         let ty = generalizedTyconRef tcref
         let infoReader = InfoReader(g,amap)
         let items =
             [| let methGroups = 
-                   AllMethInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader nenv None AccessorDomain.AccessibleFromSomeFSharpCode PreferOverrides m ty
+                   AllMethInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader nenv None ad PreferOverrides m ty
                    |> List.groupBy (fun m -> m.LogicalName)
 
                for (methName, methGroup) in methGroups do
@@ -774,20 +774,30 @@ let AddStaticContentOfTyconRefToNameEnv (g:TcGlobals) (amap: Import.ImportMap) m
                        yield KeyValuePair(methName, Item.MethodGroup(methName, methGroup, None)) 
 
                let propInfos = 
-                   AllPropInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader nenv None AccessorDomain.AccessibleFromSomeFSharpCode PreferOverrides m ty
+                   AllPropInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader nenv None ad PreferOverrides m ty
                    |> List.groupBy (fun m -> m.PropertyName)
 
                for (propName, propInfos) in propInfos do
                    let propInfos = propInfos |> List.filter (fun m -> m.IsStatic)
                    for propInfo in propInfos do 
-                       yield KeyValuePair(propName , Item.Property(propName,[propInfo])) |]
+                       yield KeyValuePair(propName , Item.Property(propName,[propInfo]))
+            
+               let fields =
+                  infoReader.GetILFieldInfosOfType(None, ad, m, ty)
+                  |> List.groupBy (fun f -> f.FieldName)
+
+               for (fieldName, fieldInfos) in fields do
+                   let fieldInfos = fieldInfos |> List.filter (fun fi -> fi.IsStatic)
+                   for fieldInfo in fieldInfos do
+                       yield KeyValuePair(fieldName, Item.ILField(fieldInfo))
+             |]
 
         { nenv with eUnqualifiedItems = nenv.eUnqualifiedItems.AddAndMarkAsCollapsible items }
     else
         nenv
 
 /// Add any implied contents of a type definition to the environment.
-let private AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition (g: TcGlobals) amap m  nenv (tcref: TyconRef) =
+let private AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition (g: TcGlobals) amap ad m  nenv (tcref: TyconRef) =
 
     let isIL = tcref.IsILTycon
     let ucrefs = if isIL then [] else tcref.UnionCasesAsList |> List.map tcref.MakeNestedUnionCaseRef
@@ -860,16 +870,16 @@ let private AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition (g: TcGlobals)
 
     let nenv = 
         if TryFindFSharpBoolAttribute g g.attrib_AutoOpenAttribute tcref.Attribs = Some true && isStaticClass g tcref then
-           AddStaticContentOfTyconRefToNameEnv g amap m nenv tcref
+           AddStaticContentOfTyconRefToNameEnv g amap ad m nenv tcref
         else
            nenv
 
     nenv
 
 /// Add a set of type definitions to the name resolution environment
-let AddTyconRefsToNameEnv bulkAddMode ownDefinition g amap m root nenv tcrefs =
+let AddTyconRefsToNameEnv bulkAddMode ownDefinition g amap ad m root nenv tcrefs =
     if isNil tcrefs then nenv else
-    let env = List.fold (AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition g amap m) nenv tcrefs
+    let env = List.fold (AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition g amap ad m) nenv tcrefs
     // Add most of the contents of the tycons en-masse, then flatten the tables if we're opening a module or namespace
     let tcrefs = Array.ofList tcrefs
     { env with
@@ -968,7 +978,7 @@ and AddModuleOrNamespaceContentsToNameEnv (g: TcGlobals) amap (ad: AccessorDomai
            let tcref = modref.NestedTyconRef tycon
            if IsEntityAccessible amap m ad tcref then Some tcref else None)
 
-    let nenv = (nenv, tcrefs) ||> AddTyconRefsToNameEnv BulkAdd.Yes false g amap m false
+    let nenv = (nenv, tcrefs) ||> AddTyconRefsToNameEnv BulkAdd.Yes false g amap ad m false
     let vrefs =
         mty.AllValsAndMembers.ToList()
         |> List.choose (fun x -> if IsAccessible ad x.Accessibility then TryMkValRefInModRef modref x else None)
@@ -993,7 +1003,7 @@ and AddEntityContentsToNameEnv g amap ad m root nenv (modref: EntityRef) =
     if modref.IsModuleOrNamespace then 
         AddModuleOrNamespaceContentsToNameEnv g amap ad m root nenv modref
     else
-        AddStaticContentOfTyconRefToNameEnv g amap m nenv modref
+        AddStaticContentOfTyconRefToNameEnv g amap ad m nenv modref
 
 /// Add a single modules or namespace to the name resolution environment
 let AddModuleOrNamespaceRefToNameEnv g amap m root ad nenv (modref: EntityRef) =

src/fsharp/NameResolution.fsi

@@ -187,7 +187,7 @@ val internal AddValRefToNameEnv                    : NameResolutionEnv -> ValRef
 val internal AddActivePatternResultTagsToNameEnv   : ActivePatternInfo -> NameResolutionEnv -> TType -> range -> NameResolutionEnv
 
 /// Add a list of type definitions to the name resolution environment 
-val internal AddTyconRefsToNameEnv                 : BulkAdd -> bool -> TcGlobals -> ImportMap -> range -> bool -> NameResolutionEnv -> TyconRef list -> NameResolutionEnv
+val internal AddTyconRefsToNameEnv                 : BulkAdd -> bool -> TcGlobals -> ImportMap -> AccessorDomain -> range -> bool -> NameResolutionEnv -> TyconRef list -> NameResolutionEnv
 
 /// Add an F# exception definition to the name resolution environment 
 val internal AddExceptionDeclsToNameEnv            : BulkAdd -> NameResolutionEnv -> TyconRef -> NameResolutionEnv

src/fsharp/TypeChecker.fs

@@ -358,7 +358,7 @@ let AddLocalExnDefnAndReport tcSink scopem env (exnc: Tycon) =
 /// Add a list of type definitions to TcEnv
 let AddLocalTyconRefs ownDefinition g amap m tcrefs env =
     if isNil tcrefs then env else
-    { env with eNameResEnv = AddTyconRefsToNameEnv BulkAdd.No ownDefinition g amap m false env.eNameResEnv tcrefs }
+    { env with eNameResEnv = AddTyconRefsToNameEnv BulkAdd.No ownDefinition g amap env.eAccessRights m false env.eNameResEnv tcrefs }
 
 /// Add a list of type definitions to TcEnv
 let AddLocalTycons g amap m (tycons: Tycon list) env =
@@ -407,7 +407,7 @@ let AddNonLocalCcu g amap scopem env assemblyName (ccu: CcuThunk, internalsVisib
     let env = AddRootModuleOrNamespaceRefs g amap scopem env modrefs
     let env =
         if isNil tcrefs then env else
-        { env with eNameResEnv = AddTyconRefsToNameEnv BulkAdd.Yes false g amap scopem true env.eNameResEnv tcrefs }
+        { env with eNameResEnv = AddTyconRefsToNameEnv BulkAdd.Yes false g amap env.eAccessRights scopem true env.eNameResEnv tcrefs }
     env
 
 /// Adjust the TcEnv to account for a fully processed "namespace" declaration in thie file
@@ -418,7 +418,7 @@ let AddLocalRootModuleOrNamespace tcSink g amap scopem env (mtyp: ModuleOrNamesp
     let tcrefs = mtyp.TypeAndExceptionDefinitions |> List.map mkLocalTyconRef
     let env = AddRootModuleOrNamespaceRefs g amap scopem env modrefs
     let env = { env with
-                    eNameResEnv = if isNil tcrefs then env.eNameResEnv else AddTyconRefsToNameEnv BulkAdd.No false g amap scopem true env.eNameResEnv tcrefs
+                    eNameResEnv = if isNil tcrefs then env.eNameResEnv else AddTyconRefsToNameEnv BulkAdd.No false g amap env.eAccessRights scopem true env.eNameResEnv tcrefs
                     eUngeneralizableItems = addFreeItemOfModuleTy mtyp env.eUngeneralizableItems }
     CallEnvSink tcSink (scopem, env.NameEnv, env.eAccessRights)
     env

tests/fsharp/Compiler/Language/OpenStaticClasses.fs

@@ -8,7 +8,7 @@ open NUnit.Framework
 
 (*
     Tests in this file evaluate whether the language supports accessing functions on static classes using open
-    The feature was added in FSharp4.7, the test cases ensure that the original errors are reproduced when the langversion:4.6 is specified
+    The feature was added in preview, the test cases ensure that the original errors are reproduced when the langversion:4.6 is specified
 *)
 
 [<TestFixture>]
@@ -49,9 +49,9 @@ module OpenSystemMathOnce =
             |]
 
     [<Test>]
-    let ``OpenStaticClassesTests - OpenSystemMathOnce - langversion:v4.7`` () =
+    let ``OpenStaticClassesTests - OpenSystemMathOnce - langversion:preview`` () =
         CompilerAssert.TypeCheckWithErrorsAndOptions
-            [| "--langversion:4.7" |]
+            [| "--langversion:preview" |]
             (baseModule + """
 module OpenSystemMathOnce =
 
@@ -79,9 +79,9 @@ module OpenSystemMathTwice =
             |]
 
     [<Test>]
-    let ``OpenStaticClassesTests - OpenSystemMathTwice - langversion:v4.7`` () =
+    let ``OpenStaticClassesTests - OpenSystemMathTwice - langversion:preview`` () =
         CompilerAssert.TypeCheckWithErrorsAndOptions
-            [| "--langversion:4.7" |]
+            [| "--langversion:preview" |]
             (baseModule + """
 module OpenSystemMathOnce =
 
@@ -106,9 +106,9 @@ module OpenMyMathOnce =
             |]
 
     [<Test>]
-    let ``OpenStaticClassesTests - OpenMyMathOnce - langversion:v4.7`` () =
+    let ``OpenStaticClassesTests - OpenMyMathOnce - langversion:preview`` () =
         CompilerAssert.TypeCheckWithErrorsAndOptions
-            [| "--langversion:4.7" |]
+            [| "--langversion:preview" |]
             (baseModule + """
 module OpenMyMathOnce = 
 
@@ -132,9 +132,9 @@ module DontOpenAutoMath =
             |]
 
     [<Test>]
-    let ``OpenStaticClassesTests - DontOpenAutoMath - langversion:v4.7`` () =
+    let ``OpenStaticClassesTests - DontOpenAutoMath - langversion:preview`` () =
         CompilerAssert.TypeCheckWithErrorsAndOptions
-            [| "--langversion:4.7" |]
+            [| "--langversion:preview" |]
             (baseModule + """
 module DontOpenAutoMath = 
 
@@ -160,9 +160,9 @@ module OpenAutoMath =
             |]
 
     [<Test>]
-    let ``OpenStaticClassesTests - OpenAutoMath - langversion:v4.7`` () =
+    let ``OpenStaticClassesTests - OpenAutoMath - langversion:preview`` () =
         CompilerAssert.TypeCheckWithErrorsAndOptions
-            [| "--langversion:4.7" |]
+            [| "--langversion:preview" |]
             (baseModule + """
 module OpenAutoMath = 
     open AutoOpenMyMath
@@ -171,3 +171,18 @@ module OpenAutoMath =
     let x = AutoMin(1.0, 2.0)
     let x2 = AutoMin(1, 2)""")
             [| |]
+
+    [<Test>]
+    let ``OpenStaticClassesTests - OpenAccessibleFields - langversion:preview`` () =
+        CompilerAssert.TypeCheckWithErrorsAndOptions
+            [| "--langversion:preview" |]
+            (baseModule + """
+module OpenAFieldFromMath =
+    open System.Math
+    
+    let pi = PI""")
+            [||]
+
+    // TODO - wait for Will's integration of testing changes that makes this easlier
+    // [<Test>]
+    // let ``OpenStaticClassesTests - InternalsVisibleWhenHavingAnIVT - langversion:preview``() = ...