if domainTy === domainTyR && rangeTy === retTyR then ty else

TType_fun (domainTyR, retTyR, flags)

TType_forall (tpsR, remapTypeAux tyenv ty)

| TType_measure unt ->

match tps with

| [] -> tps, tyenv

| _ ->

// copies bound typars, extends tpinst

and copyAndRemapAndBindTypars tyenv tps =

/// We currently break the recursion by passing in remapAttribImpl as a function parameter.

/// Use this one for any type that may be a forall type where the type variables may contain attributes

let remapTypeFull remapAttrib tyenv ty =

let remapParam tyenv (TSlotParam(nm, ty, fl1, fl2, fl3, attribs) as x) =

if isRemapEmpty tyenv then x else

let remapSlotSig remapAttrib tyenv (TSlotSig(nm, ty, ctps, methTypars, paraml, retTy) as x) =

if isRemapEmpty tyenv then x else

let tyR = remapTypeAux tyenv ty

let methTyparsR, tyenvinner = copyAndRemapAndBindTyparsFull remapAttrib tyenvinner methTypars

TSlotSig(nm, tyR, ctpsR, methTyparsR, List.mapSquared (remapParam tyenvinner) paraml, Option.map (remapTypeAux tyenvinner) retTy)

| ILAttrib _ as x -> x

| FSAttrib vref -> FSAttrib(remapValRef tmenv vref)

type RemapContext =

{ g: TcGlobals

and remapAppExpr (ctxt: RemapContext) (compgen: ValCopyFlag) (tmenv: Remap) (e1, e1ty, tyargs, args, m) origExpr =

let e1R = remapExprImpl ctxt compgen tmenv e1

let tyargsR = remapTypes tmenv tyargs

let argsR = remapExprs ctxt compgen tmenv args

if e1 === e1R && e1ty === e1tyR && tyargs === tyargsR && args === argsR then origExpr

| _ -> Construct.NewClonedTycon tycon

/// This operates over a whole nested collection of tycons and vals simultaneously *)

let tyconsR = tycons |> List.map (copyTycon compgen)

let tmenvinner = bindTycons tycons tyconsR tmenv

// Values need to be copied and renamed.

let vsR, tmenvinner = copyAndRemapAndBindVals ctxt compgen tmenvinner vs

// "if a type constructor is hidden then all its inner values and inner type constructors must also be hidden"

errorR(InternalError(sprintf "couldn't remap internal value '%s'" v.LogicalName, v.Range))

mkLocalValRef v

vref.Deref

let res = tmenvinner.tyconRefRemap[mkLocalTyconRef tycon]

res

errorR(InternalError("couldn't remap internal tycon " + showL(DebugPrint.tyconL tycon), tycon.Range))

mkLocalTyconRef tycon

tcref.Deref

let lookupTycon tycon = lookupTycon tycon

let tpsR, tmenvinner2 = tmenvCopyRemapAndBindTypars (remapAttribs ctxt tmenvinner) tmenvinner (tcd.entity_typars.Force(tcd.entity_range))

tcdR.entity_typars <- LazyWithContext.NotLazy tpsR

tcdR.entity_attribs <- tcd.entity_attribs |> remapAttribs ctxt tmenvinner2

tcdR.entity_tycon_repr <- tcd.entity_tycon_repr |> remapTyconRepr ctxt tmenvinner2

let typeAbbrevR = tcd.TypeAbbrev |> Option.map (remapType tmenvinner2)

tcdR.entity_tycon_tcaug <- tcd.entity_tycon_tcaug |> remapTyconAug tmenvinner2

let exnInfoR = tcd.ExceptionInfo |> remapTyconExnInfo ctxt tmenvinner2

match tcdR.entity_opt_data with

| Some optData -> tcdR.entity_opt_data <- Some { optData with entity_tycon_abbrev = typeAbbrevR; entity_exn_info = exnInfoR }

tcdR.SetTypeAbbrev typeAbbrevR

tcdR.SetExceptionInfo exnInfoR)

and allTyconsOfTycon (tycon: Tycon) =

seq { yield tycon