Merge pull request #9262 from dotnet/merges/master-to-release/dev16.7

Merge master to release/dev16.7

Author: brettfo

src/fsharp/IlxGen.fs

@@ -4396,7 +4396,15 @@ and GenClosureTypeDefs cenv (tref: ILTypeRef, ilGenParams, attrs, ilCloAllFreeVa
 
   let tdefs = EraseClosures.convIlxClosureDef g.ilxPubCloEnv tref.Enclosing tdef cloInfo
   tdefs
-      
+
+and GenStaticClosureTypeDefs cenv (tref: ILTypeRef, ilGenParams, attrs, ilCloAllFreeVars, ilCloLambdas, ilCtorBody, mdefs, mimpls, ext, ilIntfTys) =
+    let tdefs = GenClosureTypeDefs cenv (tref, ilGenParams, attrs, ilCloAllFreeVars, ilCloLambdas, ilCtorBody, mdefs, mimpls, ext, ilIntfTys)
+
+    // Apply the abstract attribute, turning the sealed class into abstract sealed (i.e. static class).
+    // Remove the redundant constructor.
+    tdefs |> List.map (fun td -> td.WithAbstract(true)
+                                   .With(methods= mkILMethodsFromArray (td.Methods.AsArray |> Array.filter (fun m -> not m.IsConstructor))))
+
 and GenGenericParams cenv eenv tps = 
     tps |> DropErasedTypars |> List.map (GenGenericParam cenv eenv)
 
@@ -4781,54 +4789,72 @@ and GenDelegateExpr cenv cgbuf eenvouter expr (TObjExprMethod((TSlotSig(_, deleg
                 false
          with _ ->
             false
-    
+
     // Work out the free type variables for the morphing thunk
     let takenNames = List.map nameOfVal tmvs
     let (cloAttribs, _, _, cloFreeTyvars, cloFreeVars, ilDelegeeTypeRef, ilCloFreeVars, eenvinner) =
         GetIlxClosureFreeVars cenv m [] eenvouter takenNames expr
     let ilDelegeeGenericParams = GenGenericParams cenv eenvinner cloFreeTyvars
     let ilDelegeeGenericActualsInner = mkILFormalGenericArgs 0 ilDelegeeGenericParams
 
+    // When creating a delegate that does not capture any variables, we can instead create a static closure and directly reference the method.
+    let useStaticClosure = cloFreeVars.IsEmpty
+
     // Create a new closure class with a single "delegee" method that implements the delegate.
     let delegeeMethName = "Invoke"
     let ilDelegeeTyInner = mkILBoxedTy ilDelegeeTypeRef ilDelegeeGenericActualsInner
-
+    
     let envForDelegeeUnderTypars = AddTyparsToEnv methTyparsOfOverridingMethod eenvinner
-
-    let numthis = 1
+    
+    let numthis = if useStaticClosure then 0 else 1
     let tmvs, body = BindUnitVars g (tmvs, List.replicate (List.concat slotsig.FormalParams).Length ValReprInfo.unnamedTopArg1, body)
-
+    
     // The slot sig contains a formal instantiation. When creating delegates we're only
     // interested in the actual instantiation since we don't have to emit a method impl.
     let ilDelegeeParams, ilDelegeeRet = GenActualSlotsig m cenv envForDelegeeUnderTypars slotsig methTyparsOfOverridingMethod tmvs
-
+    
     let envForDelegeeMeth = AddStorageForLocalVals g (List.mapi (fun i v -> (v, Arg (i+numthis))) tmvs) envForDelegeeUnderTypars
     let ilMethodBody = CodeGenMethodForExpr cenv cgbuf.mgbuf (SPAlways, [], delegeeMethName, envForDelegeeMeth, 1, body, (if slotSigHasVoidReturnTy slotsig then discardAndReturnVoid else Return))
     let delegeeInvokeMeth =
-        mkILNonGenericInstanceMethod
-            (delegeeMethName, ILMemberAccess.Assembly,
+        (if useStaticClosure then mkILNonGenericStaticMethod else mkILNonGenericInstanceMethod)
+            (delegeeMethName,
+             ILMemberAccess.Assembly,
              ilDelegeeParams,
              ilDelegeeRet,
              MethodBody.IL ilMethodBody)
     let delegeeCtorMeth = mkILSimpleStorageCtor(None, Some g.ilg.typ_Object.TypeSpec, ilDelegeeTyInner, [], [], ILMemberAccess.Assembly)
     let ilCtorBody = delegeeCtorMeth.MethodBody
-
+    
     let ilCloLambdas = Lambdas_return ilCtxtDelTy
     let ilAttribs = GenAttrs cenv eenvinner cloAttribs
-    let cloTypeDefs = GenClosureTypeDefs cenv (ilDelegeeTypeRef, ilDelegeeGenericParams, ilAttribs, ilCloFreeVars, ilCloLambdas, ilCtorBody, [delegeeInvokeMeth], [], g.ilg.typ_Object, [])
+    let cloTypeDefs =
+        (if useStaticClosure then GenStaticClosureTypeDefs else GenClosureTypeDefs)
+            cenv (ilDelegeeTypeRef, ilDelegeeGenericParams, ilAttribs, ilCloFreeVars, ilCloLambdas, ilCtorBody, [delegeeInvokeMeth], [], g.ilg.typ_Object, [])
     for cloTypeDef in cloTypeDefs do
         cgbuf.mgbuf.AddTypeDef(ilDelegeeTypeRef, cloTypeDef, false, false, None)
     CountClosure()
 
+    // Push the constructor for the delegee
     let ctxtGenericArgsForDelegee = GenGenericArgs m eenvouter.tyenv cloFreeTyvars
-    let ilxCloSpec = IlxClosureSpec.Create(IlxClosureRef(ilDelegeeTypeRef, ilCloLambdas, ilCloFreeVars), ctxtGenericArgsForDelegee)
-    GenGetLocalVals cenv cgbuf eenvouter m cloFreeVars
-    CG.EmitInstr cgbuf (pop ilCloFreeVars.Length) (Push [EraseClosures.mkTyOfLambdas g.ilxPubCloEnv ilCloLambdas]) (I_newobj (ilxCloSpec.Constructor, None))
-
+    if useStaticClosure then
+        GenUnit cenv eenvouter m cgbuf
+    else
+        let ilxCloSpec = IlxClosureSpec.Create(IlxClosureRef(ilDelegeeTypeRef, ilCloLambdas, ilCloFreeVars), ctxtGenericArgsForDelegee)
+        GenGetLocalVals cenv cgbuf eenvouter m cloFreeVars
+        CG.EmitInstr cgbuf (pop ilCloFreeVars.Length) (Push [EraseClosures.mkTyOfLambdas g.ilxPubCloEnv ilCloLambdas]) (I_newobj (ilxCloSpec.Constructor, None))
+    
+    // Push the function pointer to the Invoke method of the delegee
     let ilDelegeeTyOuter = mkILBoxedTy ilDelegeeTypeRef ctxtGenericArgsForDelegee
-    let ilDelegeeInvokeMethOuter = mkILNonGenericInstanceMethSpecInTy (ilDelegeeTyOuter, "Invoke", typesOfILParams ilDelegeeParams, ilDelegeeRet.Type)
-    let ilDelegeeCtorMethOuter = mkCtorMethSpecForDelegate g.ilg (ilCtxtDelTy, useUIntPtrForDelegateCtor)
+    let ilDelegeeInvokeMethOuter =
+        (if useStaticClosure then mkILNonGenericStaticMethSpecInTy else mkILNonGenericInstanceMethSpecInTy)
+            (ilDelegeeTyOuter,
+             "Invoke",
+             typesOfILParams ilDelegeeParams,
+             ilDelegeeRet.Type)
     CG.EmitInstr cgbuf (pop 0) (Push [g.ilg.typ_IntPtr]) (I_ldftn ilDelegeeInvokeMethOuter)
+
+    // Instantiate the delegate
+    let ilDelegeeCtorMethOuter = mkCtorMethSpecForDelegate g.ilg (ilCtxtDelTy, useUIntPtrForDelegateCtor)
     CG.EmitInstr cgbuf (pop 2) (Push [ilCtxtDelTy]) (I_newobj(ilDelegeeCtorMethOuter, None))
     GenSequel cenv eenvouter.cloc cgbuf sequel
 

src/fsharp/fsi/fsi.fs

@@ -1285,6 +1285,51 @@ type internal FsiDynamicCompiler
 
         { istate with boundValues = boundValues }, Completed itValue
 
+    let addCcusToIncrementalEnv istate ccuinfos =
+        let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) istate.optEnv ccuinfos
+        istate.ilxGenerator.AddExternalCcus (ccuinfos |> List.map (fun ccuinfo -> ccuinfo.FSharpViewOfMetadata))
+        { istate with optEnv = optEnv }
+
+    let importReflectionType istate reflectionTy =
+        let tcImports = istate.tcImports
+        let tcGlobals = istate.tcGlobals
+        let amap = tcImports.GetImportMap()
+
+        let prevCcuinfos = tcImports.GetImportedAssemblies()
+        
+        let rec import ccuinfos (ilTy: ILType) =
+            let ccuinfos, tinst =
+                (ilTy.GenericArgs, (ccuinfos, []))
+                ||> List.foldBack (fun ilGenericArgTy (ccuInfos, tinst) ->
+                    let ccuinfos2, ty = import ccuInfos ilGenericArgTy
+                    (ccuinfos2 @ ccuinfos, ty :: tinst))
+
+            let ty = Import.ImportILType amap range0 tinst ilTy
+            let ccuinfos =
+                match tryTcrefOfAppTy tcGlobals ty with
+                | ValueSome tcref ->
+                    match tcref.CompilationPath.ILScopeRef with
+                    | ILScopeRef.Assembly aref ->
+                        (tcImports.GetImportedAssemblies() |> List.find (fun x -> x.FSharpViewOfMetadata.AssemblyName = aref.Name)) :: ccuinfos
+                    | _ ->
+                        ccuinfos
+                | _ ->
+                    ccuinfos
+            ccuinfos, ty
+        
+        let ilTy = convertReflectionTypeToILType reflectionTy
+
+        if not (Import.CanImportILType amap range0 ilTy) then
+            invalidOp (sprintf "Unable to import type, %A." reflectionTy)
+
+        let ccuinfos, ty = import [] ilTy
+        let ccuinfos = 
+            ccuinfos 
+            |> List.distinctBy (fun x -> x.FSharpViewOfMetadata.AssemblyName)
+            |> List.filter (fun asm1 -> not (prevCcuinfos |> List.exists (fun asm2 -> asm2.FSharpViewOfMetadata.AssemblyName = asm1.FSharpViewOfMetadata.AssemblyName)))
+        // After we have successfully imported the type, then we can add newly resolved ccus to the env.
+        addCcusToIncrementalEnv istate ccuinfos, ty
+
     member __.DynamicAssemblyName = assemblyName
 
     member __.DynamicAssembly = (assemblyBuilder :> Assembly)
@@ -1381,10 +1426,8 @@ type internal FsiDynamicCompiler
             with e ->
                 tcConfigB.RemoveReferencedAssemblyByPath(m,path)
                 reraise()
-        let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) istate.optEnv ccuinfos
-        istate.ilxGenerator.AddExternalCcus (ccuinfos |> List.map (fun ccuinfo -> ccuinfo.FSharpViewOfMetadata)) 
         resolutions,
-        { istate with tcState = tcState.NextStateAfterIncrementalFragment(tcEnv); optEnv = optEnv }
+        { addCcusToIncrementalEnv istate ccuinfos with tcState = tcState.NextStateAfterIncrementalFragment(tcEnv) }
 
 
     member __.EvalDependencyManagerTextFragment (packageManager:IDependencyManagerProvider,m,path: string) =
@@ -1522,37 +1565,6 @@ type internal FsiDynamicCompiler
         | _ ->
             None
 
-    member private this.ImportReflectionType (ctok, istate, reflectionTy) =
-        let amap = istate.tcImports.GetImportMap()
-        
-        let resolveAssemblyRefOfILType istate (ilTy: ILType) =
-            let tcImports = istate.tcImports
-                
-            if ilTy.IsNominal then
-                match ilTy.TypeRef.Scope with
-                | ILScopeRef.Assembly aref ->
-                    // Simple name unification. If it fails, then try to resolve the assembly.
-                    if tcImports.TryFindDllInfo(ctok, range0, aref.Name, lookupOnly = true).IsNone then
-                        this.EvalRequireReference(ctok, istate, range0, aref.Name)
-                        |> snd
-                    else
-                        istate
-                | _ ->
-                    istate
-            else
-                istate
-        
-        let rec import istate (ilTy: ILType) =
-            let istate = resolveAssemblyRefOfILType istate ilTy
-            let istate, tinst =
-                (ilTy.GenericArgs, (istate, []))
-                ||> List.foldBack (fun ilGenericArgTy (istate, tinst) ->
-                    let istate, ty = import istate ilGenericArgTy
-                    (istate, ty :: tinst))
-            istate, Import.ImportILType amap range0 tinst ilTy
-        
-        import istate (convertReflectionTypeToILType reflectionTy)
-
     member this.AddBoundValue (ctok, errorLogger: ErrorLogger, istate, name: string, value: obj) =
         try
             match value with
@@ -1573,7 +1585,7 @@ type internal FsiDynamicCompiler
             if PrettyNaming.IsCompilerGeneratedName name then
                 invalidArg "name" (FSComp.SR.lexhlpIdentifiersContainingAtSymbolReserved() |> snd)
 
-            let istate, ty = this.ImportReflectionType(ctok, istate, value.GetType())
+            let istate, ty = importReflectionType istate (value.GetType())
             let amap = istate.tcImports.GetImportMap()
 
             let i = nextFragmentId()

src/fsharp/import.fs

@@ -287,16 +287,19 @@ let rec ImportProvidedType (env: ImportMap) (m: range) (* (tinst: TypeInst) *) (
                 tcref, [] 
 
         /// Adjust for the known primitive numeric types that accept units of measure. 
-        let tcref = 
-            if tyconRefEq g tcref g.system_Double_tcref && genericArgs.Length = 1 then g.pfloat_tcr
-            elif tyconRefEq g tcref g.system_Single_tcref && genericArgs.Length = 1 then g.pfloat32_tcr
-            elif tyconRefEq g tcref g.system_Decimal_tcref && genericArgs.Length = 1 then g.pdecimal_tcr
-            elif tyconRefEq g tcref g.system_Int16_tcref && genericArgs.Length = 1 then g.pint16_tcr
-            elif tyconRefEq g tcref g.system_Int32_tcref && genericArgs.Length = 1 then g.pint_tcr
-            elif tyconRefEq g tcref g.system_Int64_tcref && genericArgs.Length = 1 then g.pint64_tcr
-            elif tyconRefEq g tcref g.system_SByte_tcref && genericArgs.Length = 1 then g.pint8_tcr
-            else tcref
-        
+        let tcref =
+            match genericArgs with
+            | [_] -> 
+                if tyconRefEq g tcref g.system_Double_tcref then g.pfloat_tcr
+                elif tyconRefEq g tcref g.system_Single_tcref then g.pfloat32_tcr
+                elif tyconRefEq g tcref g.system_Decimal_tcref then g.pdecimal_tcr
+                elif tyconRefEq g tcref g.system_Int16_tcref then g.pint16_tcr
+                elif tyconRefEq g tcref g.system_Int32_tcref then g.pint_tcr
+                elif tyconRefEq g tcref g.system_Int64_tcref then g.pint64_tcr
+                elif tyconRefEq g tcref g.system_SByte_tcref then g.pint8_tcr
+                else tcref
+            | _ -> tcref
+
         let tps = tcref.Typars m
         if tps.Length <> genericArgs.Length then 
            error(Error(FSComp.SR.impInvalidNumberOfGenericArguments(tcref.CompiledName, tps.Length, genericArgs.Length), m))