lazyItems|> lazyMap(fun entries->

lett=new Dictionary<_,_>(entries.Length, HashIdentity.Structural)

do entries|> List.iter(fun y->letkey= keyf yin t.[key]<- y::(if t.ContainsKey(key)then t.[key]else[]))

do entries|> List.iter(fun y->

letkey= keyf y

match t.TryGetValue(key)with

|true, v-> v

t.[key]<- y:: v)

t)

memberself.Entries()= lazyItems.Force()

memberself.Filter(f)=new LazyOrderedMultiMap<'Key,'Data>(keyf, lazyItems|> lazyMap(List.filter f))

memberself.Itemwith get(x)=lett= quickMap.Force()inif t.ContainsKey xthen t.[x]else[]

with get(x)=

match quickMap.Force().TryGetValue(x)with

|true, v-> v

for i= arr.Length-1downto0do

lety= arr.[i]

letkey= y.Name

if t.ContainsKey keythen

t.[key]<- y:: t.[key]

t.[key]<-[ y]

match t.TryGetValue(key)with

|true, m-> t.[key]<- y:: m

|_-> t.[key]<-[y]

t)

interface IEnumerablewith

memberx.AsArray= array.Value

memberx.AsList= array.Value|> Array.toList

memberx.FindByName nm=if dict.Value.ContainsKey nmthen dict.Value.[nm]else[]

match dict.Value.TryGetValue(nm)with

|true, m-> m

memberx.FindByNameAndArity(nm,arity)= x.FindByName nm|> List.filter(fun x-> List.length x.Parameters= arity)

letencodeTab=new Dictionary<'T,int>(HashIdentity.Structural)

if encodeTab.ContainsKey(str)

encodeTab.[str]

match encodeTab.TryGetValue(str)with

|true, idx-> idx

letidx= nItems

encodeTab.[str]<- idx

nItems<- nItems+1

|null-> cache:=new Dictionary<_,_>(11(* sz:int*))

!cache

if cache.ContainsKey idxthen(incr count; cache.[idx])

elseletres= f idxin cache.[idx]<- res; res

match cache.TryGetValue(idx)with

|true, v->

incr count

v

letres= f idx

cache.[idx]<- res

res

letlabelsOfRawOffsets=new Dictionary<_,_>(sz/2)

letilOffsetsOfLabels=new Dictionary<_,_>(sz/2)

if labelsOfRawOffsets.ContainsKey rawOffsetthen

Some(labelsOfRawOffsets.[rawOffset])

None

match labelsOfRawOffsets.TryGetValue(rawOffset)with

|true, v-> Some v

|_-> None

match tryRawToLabel rawOffsetwith

letkey=(tryStart, tryFinish)

if sehMap.ContainsKey keythen

letprev= sehMap.[key]

sehMap.[key]<-(prev@[clause])

sehMap.[key]<-[clause])

match sehMap.TryGetValue(key)with

|true, prev-> sehMap.[key]<- prev@[clause]

|_-> sehMap.[key]<-[clause])

clauses

([], sehMap)||> Seq.fold(fun acc(KeyValue(key,bs))->[for bin bs->{Range=key; Clause=b}: ILExceptionSpec]@ acc)

seh:= sehClauses

documentType= Some(pdbDocumentGetType pdbdoc),

file= url))

letdocfun url=if tab.ContainsKey urlthen tab.[url]else failwith("Document with URL"+url+" not found in list of documents in the PDB file")

match tab.TryGetValue(url)with

|true, doc-> doc

|_-> failwith("Document with URL"+ url+" not found in list of documents in the PDB file")

Some(pdbr, docfun)

with e-> dprintn("* Warning: PDB file could not be read and will be ignored:"+e.Message); None

(emEnv, code.Labels)||> Seq.fold(fun emEnv(KeyValue(label,pc))->

letlab= ilG.DefineLabelAndLog()

pc2lab.[pc]<-(if pc2lab.ContainsKey pcthen lab:: pc2lab.[pc]else[lab])

pc2lab.[pc]<-

match pc2lab.TryGetValue(pc)with

|true, labels-> lab:: labels

|_->[lab]

envSetLabel emEnv label lab)

letpc2action= Dictionary()

letlab2pc= code.Labels

letpc= lab2pc.[lab]

pc2action.[pc]<-(if pc2action.ContainsKey pcthen pc2action.[pc]@[ action]else[ action])

pc2action.[pc]<-

match pc2action.TryGetValue(pc)with

|true, actions-> actions@[action]

|_->[action]

for ein code.Exceptionsdo

let(startTry,_endTry)= e.Range

letinstrs= code.Instrs

for pc=0to instrs.Lengthdo

if pc2action.ContainsKey pcthen

for actionin pc2action.[pc]do

match pc2action.TryGetValue(pc)with

|true, actions->

for actionin actionsdo

action()

if pc2lab.ContainsKey pcthen

for labin pc2lab.[pc]do

ilG.MarkLabelAndLog lab

match pc2lab.TryGetValue(pc)with

|true, labels->

for labin labelsdo

ilG.MarkLabelAndLog(lab)

if pc< instrs.Lengththen

match instrs.[pc]with

| I_br lwhen code.Labels.[l]= pc+1->()// compress I_br to next instruction

ifnot(origAvailBrFixups.ContainsKey tg)then

dprintn("branch target"+ formatCodeLabel tg+" not found in code")

if origAvailBrFixups.ContainsKey tgthen origAvailBrFixups.[tg]

match origAvailBrFixups.TryGetValue(tg)with

|true, fixup-> fixup

letorigRelOffset= origDest- origEndOfInstr

-128<= origRelOffset&& origRelOffset<=127

newReqdBrFixups|> List.iter(fun(newFixupLoc,endOfInstr,tg,small)->

ifnot(newAvailBrFixups.ContainsKey tg)then

failwith("target"+formatCodeLabel tg+" not found in new fixups")

letn= newAvailBrFixups.[tg]

letrelOffset=(n- endOfInstr)

if smallthen

if Bytes.get newCode newFixupLoc<>0x98then failwith"br fixupsanity check failed"

newCode.[newFixupLoc]<- b0 relOffset

checkFixup32 newCode newFixupLoc0xf00dd00fl

applyFixup32 newCode newFixupLoc relOffset

with:? KeyNotFoundException->())

match newAvailBrFixups.TryGetValue(tg)with

|true, n->

letrelOffset= n- endOfInstr

if smallthen

if Bytes.get newCode newFixupLoc<>0x98then failwith"br fixupsanity check failed"

newCode.[newFixupLoc]<- b0 relOffset

checkFixup32 newCode newFixupLoc0xf00dd00fl

applyFixup32 newCode newFixupLoc relOffset

|_-> failwith("target"+ formatCodeLabel tg+" not found in new fixups"))

newCode, newReqdStringFixups, newExnClauses, newSeqPoints, newScopes

letpc2pos= Array.zeroCreate(instrs.Length+1)

letpc2labs= Dictionary()

for(KeyValue(lab, pc))in code.Labelsdo

if pc2labs.ContainsKey pcthen pc2labs.[pc]<- lab:: pc2labs.[pc]else pc2labs.[pc]<-[lab]

for KeyValue(lab, pc)in code.Labelsdo

match pc2labs.TryGetValue(pc)with

|true, labels->

pc2labs.[pc]<- lab:: labels

|_-> pc2labs.[pc]<-[lab]

for pc=0to instrs.Lengthdo

if pc2labs.ContainsKey pcthen

for labin pc2labs.[pc]do

codebuf.RecordAvailBrFixup lab

match pc2labs.TryGetValue(pc)with

|true, labels->

for labin labelsdo

codebuf.RecordAvailBrFixup(lab)

pc2pos.[pc]<- codebuf.code.Position

if pc< instrs.Lengththen

match instrs.[pc]with

staticParameters|> Array.map(fun sp->

lettypeBeforeArgumentsName= typeBeforeArguments.PUntaint((fun st-> st.Name), m)

letspName= sp.PUntaint((fun sp-> sp.Name), m)

ifnot(argSpecsTable.ContainsKey spName)then

if sp.PUntaint((fun sp-> sp.IsOptional), m)then

match sp.PUntaint((fun sp-> sp.RawDefaultValue), m)with

|null-> error(Error(FSComp.SR.etStaticParameterRequiresAValue(spName, typeBeforeArgumentsName, typeBeforeArgumentsName, spName), range0))

| v-> v

error(Error(FSComp.SR.etProvidedTypeReferenceMissingArgument(spName), range0))

letarg= argSpecsTable.[spName]

match argSpecsTable.TryGetValue(spName)with

|true, arg->

sp.PUntaint((fun sp->

|"System.Char"-> box(char arg)

|"System.Boolean"-> box(arg="True")

|"System.String"-> box(string arg)

| s-> error(Error(FSComp.SR.etUnknownStaticArgumentKind(s, typeLogicalName), range0)))

| s-> error(Error(FSComp.SR.etUnknownStaticArgumentKind(s, typeLogicalName), range0))

if sp.PUntaint((fun sp-> sp.IsOptional), m)then

match sp.PUntaint((fun sp-> sp.RawDefaultValue), m)with

|null-> error(Error(FSComp.SR.etStaticParameterRequiresAValue(spName, typeBeforeArgumentsName, typeBeforeArgumentsName, spName), range0))

| v-> v

error(Error(FSComp.SR.etProvidedTypeReferenceMissingArgument(spName), range0)))

match TryApplyProvidedType(typeBeforeArguments, None, staticArgs, range0)with

| Some(typeWithArguments, checkTypeName)->

letnm= PropKey(pdef.Name, pdef.Args, pdef.CallingConv)

if ht.ContainsKey nmthen

match ht.TryGetValue(nm)with

|true,(idx, pd)->

ht.[nm]<-(idx, MergePropertyPair m pd pdef)

ht.[nm]<-(ht.Count, pdef)

if n= System.Int32.MaxValuethen error(InternalError("recursive label graph",m))

if codeLabelToCodeLabel.ContainsKey lblthen

lab2pc(n+1) codeLabelToCodeLabel.[lbl]

codeLabelToPC.[lbl]

match codeLabelToCodeLabel.TryGetValue(lbl)with

|true, l-> lab2pc(n+1) l

|_-> codeLabelToPC.[lbl]

let mutablelastSeqPoint= None

letprops=new Dictionary<PropInfo,PropInfo>(hashIdentity)

if props.ContainsKey(pinfo)then

match props.[pinfo], pinfowith

| FSProp(_,typ,Some vref1,_), FSProp(_,_,_,Some vref2)

| FSProp(_,typ,_,Some vref2), FSProp(_,_,Some vref1,_)->

letpinfo= FSProp(g,typ,Some vref1,Some vref2)

props.[pinfo]<- pinfo

match props.TryGetValue(pinfo), pinfowith

|(true, FSProp(_, typ, Some vref1,_)), FSProp(_,_,_, Some vref2)

|(true, FSProp(_, typ,_, Some vref2)), FSProp(_,_, Some vref1,_)->

letpinfo= FSProp(g,typ,Some vref1,Some vref2)

props.[pinfo]<- pinfo

props.[pinfo]<- pinfo

letvRaw= pe.PUntaint(id,m)

ifnot(varConv.ContainsKey vRaw)then

lettypeProviderDesignation= ExtensionTyping.DisplayNameOfTypeProvider(pe.TypeProvider, m)

error(NumberedError(FSComp.SR.etIncorrectParameterExpression(typeProviderDesignation,vRaw.Name), m))

varConv.[vRaw]

match varConv.TryGetValue(vRaw)with

|true, v-> v

lettypeProviderDesignation= ExtensionTyping.DisplayNameOfTypeProvider(pe.TypeProvider, m)

error(NumberedError(FSComp.SR.etIncorrectParameterExpression(typeProviderDesignation,vRaw.Name), m))

let_,(resExpr,_)= exprToExprAndWitnessfalse expr

letimmediateProps= GetImmediateIntrinsicPropInfosOfType(None,AccessibleFromSomewhere) cenv.g cenv.amap m typ

if hash.ContainsKey(nm)then hash.[nm]else[]

match hash.TryGetValue(nm)with

|true, h-> h