split service.fs

src/absil/ilwrite.fs

@@ -87,9 +87,15 @@ type ByteBuffer with
             buf.EmitByte 0x0uy
 
     // Emit compressed untagged integer
-    member buf.EmitZUntaggedIndex big idx = 
+    member buf.EmitZUntaggedIndex nm sz big idx = 
         if big then buf.EmitInt32 idx
-        elif idx > 0xffff then failwith "EmitZUntaggedIndex: too big for small address or simple index"
+        elif idx > 0xffff then 
+#if NETSTANDARD1_6
+            let trace = "no stack trace on.NET Standard 1.6"
+#else
+            let trace = (new System.Diagnostics.StackTrace()).ToString()
+#endif
+            failwithf "EmitZUntaggedIndex: index into table '%d' is too big for small address or simple index, idx = %d, big = %A, size of table = %d, stack = %s" nm idx big sz trace
         else buf.EmitInt32AsUInt16 idx
 
     // Emit compressed tagged integer
@@ -3198,8 +3204,10 @@ let writeILMetadataAndCode (generatePdb, desiredMetadataVersion, ilg, emitTailca
 
     let codedTables = 
 
+        let sizesTable = Array.map Array.length sortedTables
         let bignessTable = Array.map (fun rows -> Array.length rows >= 0x10000) sortedTables
         let bigness (tab:int32) = bignessTable.[tab]
+        let size (tab:int32) = sizesTable.[tab]
 
         let codedBigness nbits tab =
           (tableSize tab) >= (0x10000 >>> nbits)
@@ -3323,10 +3331,12 @@ let writeILMetadataAndCode (generatePdb, desiredMetadataVersion, ilg, emitTailca
                     | _ when t = RowElementTags.ULong         -> tablesBuf.EmitInt32 n
                     | _ when t = RowElementTags.Data          -> recordRequiredDataFixup requiredDataFixups tablesBuf (tablesStreamStart + tablesBuf.Position) (n, false)
                     | _ when t = RowElementTags.DataResources -> recordRequiredDataFixup requiredDataFixups tablesBuf (tablesStreamStart + tablesBuf.Position) (n, true)
-                    | _ when t = RowElementTags.Guid          -> tablesBuf.EmitZUntaggedIndex guidsBig (guidAddress n)
-                    | _ when t = RowElementTags.Blob          -> tablesBuf.EmitZUntaggedIndex blobsBig  (blobAddress n)
-                    | _ when t = RowElementTags.String        -> tablesBuf.EmitZUntaggedIndex stringsBig (stringAddress n)
-                    | _ when t <= RowElementTags.SimpleIndexMax         -> tablesBuf.EmitZUntaggedIndex (bigness (t - RowElementTags.SimpleIndexMin)) n
+                    | _ when t = RowElementTags.Guid          -> tablesBuf.EmitZUntaggedIndex -3 guidsStreamPaddedSize guidsBig (guidAddress n)
+                    | _ when t = RowElementTags.Blob          -> tablesBuf.EmitZUntaggedIndex -2 blobsStreamPaddedSize blobsBig  (blobAddress n)
+                    | _ when t = RowElementTags.String        -> tablesBuf.EmitZUntaggedIndex -1 stringsStreamPaddedSize stringsBig (stringAddress n)
+                    | _ when t <= RowElementTags.SimpleIndexMax         -> 
+                        let tnum = t - RowElementTags.SimpleIndexMin
+                        tablesBuf.EmitZUntaggedIndex tnum (size tnum) (bigness tnum) n
                     | _ when t <= RowElementTags.TypeDefOrRefOrSpecMax  -> tablesBuf.EmitZTaggedIndex (t - RowElementTags.TypeDefOrRefOrSpecMin)  2 tdorBigness n
                     | _ when t <= RowElementTags.TypeOrMethodDefMax     -> tablesBuf.EmitZTaggedIndex (t - RowElementTags.TypeOrMethodDefMin)     1 tomdBigness n
                     | _ when t <= RowElementTags.HasConstantMax         -> tablesBuf.EmitZTaggedIndex (t - RowElementTags.HasConstantMin)         2 hcBigness   n

vsintegration/tests/MockTypeProviders/DummyProviderForLanguageServiceTesting/DummyProviderForLanguageServiceTesting.fs

@@ -113,33 +113,36 @@ module internal TPModule =
 
 // Used by unit testing to check that Dispose is being called on the type provider
 module GlobalCounters = 
-    let mutable creations = 0
-    let mutable disposals = 0
-    let mutable configs = ([]: TypeProviderConfig list)
-    let GetTotalCreations() = creations
-    let GetTotalDisposals() = disposals
+    let counterLock = obj()
+    let mutable private creations = 0
+    let mutable private disposals = 0
+    let mutable private configs = ([]: TypeProviderConfig list)
+    let GetTotalCreations() = lock counterLock (fun () -> creations)
+    let GetTotalDisposals() = lock counterLock (fun () -> disposals)
+    let IncrementCreations() = lock counterLock (fun () -> creations <- creations + 1)
+    let IncrementDisposals() = lock counterLock (fun () -> disposals <- disposals + 1)
+    let AddConfig c = lock counterLock (fun () -> configs <- c :: configs)
+    let GetConfigs() = lock counterLock (fun () -> configs)
     let CheckAllConfigsDisposed() = 
-        for c in configs do 
+        for c in GetConfigs() do 
             try 
                 c.SystemRuntimeContainsType("System.Object") |> ignore
                 failwith "expected configuration object to be disposed"
             with :? System.ObjectDisposedException -> 
                 ()
 
-
-
 [<TypeProvider>]
 type HelloWorldProvider(config: TypeProviderConfig) = 
     inherit TypeProviderForNamespaces(TPModule.namespaceName,TPModule.types)
-    do GlobalCounters.creations <- GlobalCounters.creations + 1                         
+    do GlobalCounters.IncrementCreations()
     let mutable disposed = false
-    do GlobalCounters.configs <- config :: GlobalCounters.configs
+    do GlobalCounters.AddConfig config
     interface System.IDisposable with 
         member x.Dispose() = 
             System.Diagnostics.Debug.Assert(not disposed)
             disposed <- true
-            GlobalCounters.disposals <- GlobalCounters.disposals + 1                         
-            if GlobalCounters.disposals % 5 = 0 then failwith "simulate random error during disposal"
+            do GlobalCounters.IncrementDisposals()
+            if GlobalCounters.GetTotalDisposals() % 5 = 0 then failwith "simulate random error during disposal"
 
 
 // implementation of a poorly behaving TP that sleeps for various numbers of seconds when traversing into members.

vsintegration/tests/UnitTests/LegacyLanguageService/Tests.LanguageService.Script.fs

@@ -1624,8 +1624,10 @@ type UsingMSBuild() as this =
 
             // The disposals should be at least one less 
             Assert.IsTrue(countDisposals() < i, "Check1, countDisposals() < i, iteration " + string i)
-            Assert.IsTrue(countCreations() >= countDisposals(), "Check2, countCreations() >= countDisposals(), iteration " + string i)
-            Assert.IsTrue(countCreations() = i, "Check3, countCreations() = i, iteration " + string i)
+            let c = countCreations()
+            let d = countDisposals()
+            Assert.IsTrue(c >= countDisposals(), "Check2, countCreations() >= countDisposals(), iteration " + string i + ", countCreations() = " + string c + ", countDisposals() = " + string d)
+            Assert.IsTrue((c = i), "Check3, countCreations() = i, iteration " + string i + ", countCreations() = " + string c)
             if not clearing then 
                 // By default we hold 3 build incrementalBuilderCache entries and 5 typeCheckInfo entries, so if we're not clearing
                 // there should be some roots to project builds still present