Fix 16105

src/Compiler/Optimize/Optimizer.fs

@@ -690,7 +690,10 @@ let GetInfoForVal cenv env m (vref: ValRef) =
             GetInfoForLocalValue cenv env vref.binding m
         else
             GetInfoForNonLocalVal cenv env vref
+    res
 
+let GetInfoForValWithCheck cenv env m (vref: ValRef) =  
+    let res = GetInfoForVal cenv env m vref
     check vref res |> ignore
     res
 
@@ -3062,11 +3065,14 @@ and TryOptimizeVal cenv env (vOpt: ValRef option, mustInline, inlineIfLambda, va
         failwith "tuple, union and record values cannot be marked 'inline'"
 
     | UnknownValue when mustInline ->
-        warning(Error(FSComp.SR.optValueMarkedInlineHasUnexpectedValue(), m)); None
+        warning(Error(FSComp.SR.optValueMarkedInlineHasUnexpectedValue(), m))
+        None
 
     | _ when mustInline ->
-        warning(Error(FSComp.SR.optValueMarkedInlineCouldNotBeInlined(), m)); None
-    | _ -> None 
+        warning(Error(FSComp.SR.optValueMarkedInlineCouldNotBeInlined(), m))
+        None
+
+    | _ -> None
 
 and TryOptimizeValInfo cenv env m vinfo = 
     if vinfo.HasEffect then None else TryOptimizeVal cenv env (None, false, false, vinfo.Info, m)
@@ -3089,7 +3095,7 @@ and OptimizeVal cenv env expr (v: ValRef, m) =
 
     let g = cenv.g
 
-    let valInfoForVal = GetInfoForVal cenv env m v 
+    let valInfoForVal = GetInfoForValWithCheck cenv env m v 
 
     match TryOptimizeVal cenv env (Some v, v.MustInline, v.InlineIfLambda, valInfoForVal.ValExprInfo, m) with
     | Some e -> 
@@ -3402,7 +3408,7 @@ and TryInlineApplication cenv env finfo (tyargs: TType list, args: Expr list, m)
                                 | _ -> false
                             | _ -> false
                     | _ -> false
-                | _ -> false                                          
+                | _ -> false
 
         if isValFromLazyExtensions then None else
 
@@ -3421,6 +3427,15 @@ and TryInlineApplication cenv env finfo (tyargs: TType list, args: Expr list, m)
 
         if isGetHashCode then None else
 
+        let isApplicationComplete =
+            match finfo.Info with
+            | ValValue (_, CurriedLambdaValue (_, _, _, Expr.Lambda (_, _, _, _, Expr.App (Expr.Val(vr,_,_), _, _, _, _), _, _), _) ) ->
+                IsPartialExprVal (GetInfoForVal cenv env m vr).ValExprInfo
+            | _ ->
+                false
+
+        if isApplicationComplete then None else
+
         // Inlining lambda 
         let f2R = CopyExprForInlining cenv false f2 m
 
@@ -3598,7 +3613,7 @@ and OptimizeApplication cenv env (f0, f0ty, tyargs, args, m) =
                  // Note we also have to check the argument count to ensure this is a direct call (or a partial application).
                  let doesNotMakeCriticalTailcall = 
                      vref.MakesNoCriticalTailcalls || 
-                     (let valInfoForVal = GetInfoForVal cenv env m vref in valInfoForVal.ValMakesNoCriticalTailcalls) ||
+                     (let valInfoForVal = GetInfoForValWithCheck cenv env m vref in valInfoForVal.ValMakesNoCriticalTailcalls) ||
                      (match env.functionVal with | None -> false | Some (v, _) -> valEq vref.Deref v)
                  if doesNotMakeCriticalTailcall then
                     let numArgs = otherArgs.Length + newArgs.Length

tests/AheadOfTime/Trimming/check.ps1

@@ -39,7 +39,7 @@ function CheckTrim($root, $tfm, $outputfile, $expected_len) {
 # error NETSDK1124: Trimming assemblies requires .NET Core 3.0 or higher.
 
 # Check net7.0 trimmed assemblies
-CheckTrim -root "SelfContained_Trimming_Test" -tfm "net8.0" -outputfile "FSharp.Core.dll" -expected_len 287232
+CheckTrim -root "SelfContained_Trimming_Test" -tfm "net8.0" -outputfile "FSharp.Core.dll" -expected_len 303104
 
 # Check net7.0 trimmed assemblies
-CheckTrim -root "StaticLinkedFSharpCore_Trimming_Test" -tfm "net8.0" -outputfile "StaticLinkedFSharpCore_Trimming_Test.dll" -expected_len 8821248
+CheckTrim -root "StaticLinkedFSharpCore_Trimming_Test" -tfm "net8.0" -outputfile "StaticLinkedFSharpCore_Trimming_Test.dll" -expected_len 8839680

tests/FSharp.Compiler.ComponentTests/Debugger/PortablePdbs.fs

@@ -74,9 +74,7 @@ module Baz =
                 Line 16, Col 20, Line 16, Col 22
                 Line 21, Col 20, Line 21, Col 22
             ]
-            VerifyDocuments [
-                Path.Combine(Environment.CurrentDirectory, "test.fs")
-            ]
+            VerifyDocuments [ "test.fs" ]
         ]
 
     [<Fact>]
@@ -100,9 +98,4 @@ module M =
         |> withPortablePdb
         |> compile
         |> shouldSucceed
-        |> verifyPdb [
-            VerifyDocuments [
-                Path.Combine(Environment.CurrentDirectory, "test.fsi")
-                Path.Combine(Environment.CurrentDirectory, "test.fs")
-            ]
-        ]
+        |> verifyPdb [ VerifyDocuments [ "test.fsi"; "test.fs" ] ]

tests/FSharp.Compiler.ComponentTests/EmittedIL/NoCompilerInlining.fs

@@ -5,7 +5,206 @@ namespace EmittedIL
 open Xunit
 open FSharp.Test.Compiler
 
-module ``NoCompilerInlining`` =
+module NoCompilerInlining =
+
+    [<Fact>]
+    let ``Methods marked internal not available for cross module inlining``() =
+
+        let outerModule =
+            FSharpWithFileName
+                "outerModule.fs"
+                """
+module internal OuterModule
+    open System.Runtime.CompilerServices
+
+    [<assembly:InternalsVisibleTo("middleModule")>]
+    do ()
+
+    let sayOuterModuleHello () = System.Console.WriteLine("Hello World") """
+            |> withOptimize
+            |> asLibrary
+            |> withName "outerLibrary"
+
+        let middleModule =
+            FSharpWithFileName
+                "middleModule.fs"
+                """
+module MiddleModule
+    let sayMiddleModuleHello () = OuterModule.sayOuterModuleHello()"""
+            |> withOptimize
+            |> withReferences [outerModule]
+            |> asLibrary
+            |> withName "middleModule"
+
+        FSharpWithFileName
+            "program.fs"
+            """MiddleModule.sayMiddleModuleHello()"""
+        |> withOptimize
+        |> withReferences [middleModule; outerModule]
+        |> withName "Program"
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> verifyIL [ """
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  call       void [middleModule]MiddleModule::sayMiddleModuleHello()
+    IL_0005:  ret
+  } 
+""" ]
+
+    [<Fact>]
+    let ``Methods marked public available for cross module inlining``() =
+
+        let outerModule =
+            FSharpWithFileName
+                "outerModule.fs"
+                """
+module  OuterModule
+    open System.Runtime.CompilerServices
+
+    let sayOuterModuleHello () = System.Console.WriteLine("Hello World") """
+            |> withOptimize
+            |> asLibrary
+            |> withName "outerLibrary"
+
+        let middleModule =
+            FSharpWithFileName
+                "middleModule.fs"
+                """
+module MiddleModule
+    let sayMiddleModuleHello () = OuterModule.sayOuterModuleHello()"""
+            |> withOptimize
+            |> withReferences [outerModule]
+            |> asLibrary
+            |> withName "middleModule"
+
+        FSharpWithFileName
+            "program.fs"
+            """MiddleModule.sayMiddleModuleHello()"""
+        |> withOptimize
+        |> withReferences [middleModule; outerModule]
+        |> withName "Program"
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> verifyIL [ """
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ldstr      "Hello World"
+    IL_0005:  call       void [runtime]System.Console::WriteLine(string)
+    IL_000a:  ret
+  } 
+""" ]
+
+
+    [<Fact>]
+    let ``Nested Module marked internal not available for cross module inlining``() =
+
+        let outerModule =
+            FSharpWithFileName
+                "outerModule.fs"
+                """
+module OuterModule
+    open System.Runtime.CompilerServices
+
+    [<assembly:InternalsVisibleTo("middleModule")>]
+    do ()
+
+    module internal nestedModule =
+        let sayNestedModuleHello () = System.Console.WriteLine("Hello World")
+
+    let sayOuterModuleHello () = nestedModule.sayNestedModuleHello () """
+            |> withOptimize
+            |> asLibrary
+            |> withName "outerLibrary"
+
+        let middleModule =
+            FSharpWithFileName
+                "middleModule.fs"
+                """
+module MiddleModule
+    let sayMiddleModuleHello () = OuterModule.sayOuterModuleHello()"""
+            |> withOptimize
+            |> withReferences [outerModule]
+            |> asLibrary
+            |> withName "middleModule"
+
+        FSharpWithFileName
+            "program.fs"
+            """MiddleModule.sayMiddleModuleHello()"""
+        |> withOptimize
+        |> withReferences [middleModule; outerModule]
+        |> withName "Program"
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> verifyIL [ """
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ldstr      "Hello World"
+    IL_0005:  call       void [runtime]System.Console::WriteLine(string)
+    IL_000a:  ret
+  } 
+""" ]
+
+    [<Fact>]
+    let ``Nested Module marked public available for cross module inlining``() =
+
+        let outerModule =
+            FSharpWithFileName
+                "outerModule.fs"
+                """
+module OuterModule
+    open System.Runtime.CompilerServices
+
+    module nestedModule =
+        let sayNestedModuleHello () = System.Console.WriteLine("Hello World")
+
+    let sayOuterModuleHello () = nestedModule.sayNestedModuleHello () """
+            |> withOptimize
+            |> asLibrary
+            |> withName "outerLibrary"
+
+        let middleModule =
+            FSharpWithFileName
+                "middleModule.fs"
+                """
+module MiddleModule
+    let sayMiddleModuleHello () = OuterModule.sayOuterModuleHello()"""
+            |> withOptimize
+            |> withReferences [outerModule]
+            |> asLibrary
+            |> withName "middleModule"
+
+        FSharpWithFileName
+            "program.fs"
+            """MiddleModule.sayMiddleModuleHello()"""
+        |> withOptimize
+        |> withReferences [middleModule; outerModule]
+        |> withName "Program"
+        |> compileExeAndRun
+        |> shouldSucceed
+        |> verifyIL [ """
+  .method public static void  main@() cil managed
+  {
+    .entrypoint
+    
+    .maxstack  8
+    IL_0000:  ldstr      "Hello World"
+    IL_0005:  call       void [runtime]System.Console::WriteLine(string)
+    IL_000a:  ret
+  } 
+""" ]
+
+
+
     [<Fact>]
     let ``Function marked with NoCompilerInlining is not inlined by the compiler``() =
         FSharp """

tests/FSharp.Test.Utilities/Compiler.fs

@@ -366,6 +366,10 @@ module rec Compiler =
     let FSharp (source: string) : CompilationUnit =
         Fs source
 
+    let FSharpWithFileName name (source: string) : CompilationUnit =
+        fsFromString (SourceCodeFileKind.Fs({FileName=name; SourceText=Some source }))
+        |> FS
+
     let FsFromPath (path: string) : CompilationUnit =
         fsFromString (SourceFromPath path)
         |> FS
@@ -1362,12 +1366,13 @@ Actual:
         if documents <> expectedDocuments then
             failwith $"Expected documents are different from PDB.\nExpected: %A{expectedDocuments}\nActual: %A{documents}"
 
-    let private verifyPdbOptions reader options =
+    let private verifyPdbOptions optOutputPath reader options =
+        let outputPath = Path.GetDirectoryName(optOutputPath |> Option.defaultValue ".")
         for option in options do
             match option with
             | VerifyImportScopes scopes -> verifyPdbImportTables reader scopes
             | VerifySequencePoints sp -> verifySequencePoints reader sp
-            | VerifyDocuments docs -> verifyDocuments reader docs
+            | VerifyDocuments docs -> verifyDocuments reader (docs |> List.map(fun doc -> Path.Combine(outputPath, doc)))
             | _ -> failwith $"Unknown verification option: {option.ToString()}"
 
     let private verifyPortablePdb (result: CompilationOutput) options : unit =
@@ -1386,7 +1391,7 @@ Actual:
                 | _ -> failwith "Only F# compilations are supported when verifying PDBs."
 
             verifyPdbFormat reader compilationType
-            verifyPdbOptions reader options
+            verifyPdbOptions result.OutputPath reader options
         | _ -> failwith "Output path is not set, please make sure compilation was successfull."
 
         ()

tests/FSharp.Test.Utilities/CompilerAssert.fs

@@ -439,9 +439,10 @@ module rec CompilerAssertHelpers =
                     | Some text ->
                         // In memory source file copy it to the build directory
                         let source = item.ChangeExtension
-                        File.WriteAllText (source.GetSourceFileName, text)
-                        disposals.Add(disposeFile source.GetSourceFileName)
-                        yield source
+                        let destFileName = Path.Combine(outputDirectory.FullName, Path.GetFileName(source.GetSourceFileName))
+                        File.WriteAllText (destFileName, text)
+                        disposals.Add(disposeFile destFileName)
+                        yield source.WithFileName(destFileName)
                     | None ->
                         // On Disk file
                         let sourceFileName = item.GetSourceFileName

vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj

@@ -6,6 +6,7 @@
     <OutputType>Library</OutputType>
     <NoWarn>$(NoWarn);75</NoWarn>
     <NoWarn>$(NoWarn);44</NoWarn><!-- warning about Roslyn API only for F# and TypeScript -->
+    <NoWarn>$(NoWarn);FS3511</NoWarn> <!-- This state machine is not statically compilable.@@@@ Do we really need this -->
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <OtherFlags>$(OtherFlags) --warnon:1182 --subsystemversion:6.00</OtherFlags>
     <EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>