reduce allocations

Author: vasily-kirichenko

src/fsharp/MethodOverrides.fs

@@ -293,7 +293,7 @@ module DispatchSlotChecking =
                     match  overrides |> List.filter (IsPartialMatch g amap m dispatchSlot)  with 
                     | [] -> 
                         match overrides |> List.filter (fun overrideBy -> IsNameMatch dispatchSlot overrideBy && 
-                                                                            IsImplMatch g dispatchSlot overrideBy)  with 
+                                                                          IsImplMatch g dispatchSlot overrideBy)  with 
                         | [] -> 
                             noimpl()
                         | [ Override(_,_,_,(mtps,_),argTys,_,_,_) as overrideBy ] -> 
@@ -307,12 +307,10 @@ module DispatchSlotChecking =
                             errorR(Error(FSComp.SR.typrelOverloadNotFound(FormatMethInfoSig g amap m denv dispatchSlot, FormatMethInfoSig g amap m denv dispatchSlot),overrideBy.Range))
 
                     | [ overrideBy ] -> 
-
-                        match dispatchSlots  |> List.filter (fun (RequiredSlot(dispatchSlot,_)) -> OverrideImplementsDispatchSlot g amap m dispatchSlot overrideBy) with 
-                        | [] -> 
+                        if dispatchSlots |> List.exists (fun (RequiredSlot(dispatchSlot,_)) -> OverrideImplementsDispatchSlot g amap m dispatchSlot overrideBy) then
                             // Error will be reported below in CheckOverridesAreAllUsedOnce 
                             ()
-                        | _ -> 
+                        else
                             noimpl()
 
                     | _ -> 

src/fsharp/tast.fs

@@ -4398,19 +4398,18 @@ let fslibValRefEq fslibCcu vref1 vref2 =
 /// This takes into account the possibility that they may have type forwarders
 let primEntityRefEq compilingFslib fslibCcu (x : EntityRef) (y : EntityRef) = 
     x === y ||
-    match x.IsResolved,y.IsResolved with 
-    | true, true when not compilingFslib -> x.ResolvedTarget === y.ResolvedTarget 
-    | _ -> 
-    match x.IsLocalRef,y.IsLocalRef with 
-    | false, false when 
+    
+    if x.IsResolved && y.IsResolved && not compilingFslib then
+        x.ResolvedTarget === y.ResolvedTarget 
+    elif not x.IsLocalRef && not y.IsLocalRef &&
         (// Two tcrefs with identical paths are always equal
          nonLocalRefEq x.nlr y.nlr || 
          // The tcrefs may have forwarders. If they may possibly be equal then resolve them to get their canonical references
          // and compare those using pointer equality.
-         (not (nonLocalRefDefinitelyNotEq x.nlr y.nlr) && x.Deref === y.Deref)) -> 
+         (not (nonLocalRefDefinitelyNotEq x.nlr y.nlr) && x.Deref === y.Deref)) then
         true
-    | _ -> 
-        compilingFslib && fslibEntityRefEq  fslibCcu x y  
+    else
+        compilingFslib && fslibEntityRefEq fslibCcu x y  
 
 /// Primitive routine to compare two UnionCaseRef's for equality
 let primUnionCaseRefEq compilingFslib fslibCcu (UCRef(tcr1,c1) as uc1) (UCRef(tcr2,c2) as uc2) = 

src/utils/prim-lexing.fs

@@ -184,9 +184,9 @@ namespace Internal.Utilities.Text.Lexing
                     if lexBuffer.IsPastEndOfStream then failwith "End of file on lexing stream";
                     lexBuffer.IsPastEndOfStream <- true;
                     //printf "state %d --> %d on eof\n" state snew;
-                    scanUntilSentinel(lexBuffer,snew)
+                    scanUntilSentinel lexBuffer snew
             else 
-                scanUntilSentinel(lexBuffer, state)
+                scanUntilSentinel lexBuffer state
 
         let onAccept (lexBuffer:LexBuffer<char>,a) = 
             lexBuffer.LexemeLength <- lexBuffer.BufferScanLength;
@@ -201,7 +201,7 @@ namespace Internal.Utilities.Text.Lexing
         let numUnicodeCategories = 30 
         let numLowUnicodeChars = 128 
         let numSpecificUnicodeChars = (trans.[0].Length - 1 - numLowUnicodeChars - numUnicodeCategories)/2
-        let lookupUnicodeCharacters (state,inp) = 
+        let lookupUnicodeCharacters state inp =
             let inpAsInt = int inp
             // Is it a fast ASCII character?
             if inpAsInt < numLowUnicodeChars then 
@@ -235,7 +235,7 @@ namespace Internal.Utilities.Text.Lexing
                 loop 0
         let eofPos    = numLowUnicodeChars + 2*numSpecificUnicodeChars + numUnicodeCategories 
 
-        let rec scanUntilSentinel(lexBuffer,state) =
+        let rec scanUntilSentinel lexBuffer state =
             // Return an endOfScan after consuming the input 
             let a = int accept.[state] 
             if a <> sentinel then 
@@ -251,14 +251,14 @@ namespace Internal.Utilities.Text.Lexing
                 let inp = lexBuffer.Buffer.[lexBuffer.BufferScanPos]
 
                 // Find the new state
-                let snew = lookupUnicodeCharacters (state,inp)
+                let snew = lookupUnicodeCharacters state inp
 
                 if snew = sentinel then 
                     lexBuffer.EndOfScan()
                 else 
                     lexBuffer.BufferScanLength <- lexBuffer.BufferScanLength + 1;
                     //printf "state %d --> %d on '%c' (%d)\n" s snew (char inp) inp;
-                    scanUntilSentinel(lexBuffer,snew)
+                    scanUntilSentinel lexBuffer snew
 
         // Each row for the Unicode table has format 
         //      128 entries for ASCII characters
@@ -268,6 +268,6 @@ namespace Internal.Utilities.Text.Lexing
 
         member tables.Interpret(initialState,lexBuffer : LexBuffer<char>) = 
             startInterpret(lexBuffer)
-            scanUntilSentinel(lexBuffer, initialState)
+            scanUntilSentinel lexBuffer initialState
 
         static member Create(trans,accept) = new UnicodeTables(trans,accept)