Skip to content

Remove obsolete list aliases #1556

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
dsyme merged 4 commits into from
Sep 23, 2016
Merged

Remove obsolete list aliases #1556

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
68d05b1
Bye bye FlatList
forki Sep 21, 2016
080daae
Bye bye ILList
forki Sep 21, 2016
303ab69
Remove Flatlist from proto
forki Sep 21, 2016
5efdb73
Remove more tautological calls
forki Sep 21, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
233 changes: 48 additions & 185 deletions src/absil/il.fs
View file
Open in desktop

Large diffs are not rendered by default.

62 changes: 6 additions & 56 deletions src/absil/il.fsi
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,20 +7,6 @@ module internal Microsoft.FSharp.Compiler.AbstractIL.IL
open Internal.Utilities
open System.Collections.Generic

/// The type used to store relatively small lists in the Abstract IL data structures, i.e. for ILTypes, ILGenericArgs, ILParameters and ILLocals.
/// See comments in il.fs for why we've isolated this representation and the possible future choices we might use here.
#if ABSIL_USES_ARRAY_FOR_ILLIST
type ILList<'T> = 'T []
#endif

#if ABSIL_USES_THREELIST_FOR_ILLIST
type ILList<'T> = ThreeList<'T>
#endif

//#if ABSIL_USES_LIST_FOR_ILLIST
type ILList<'T> = 'T list
//#endif

type PrimaryAssembly =
| Mscorlib
| DotNetCore
Expand Down Expand Up @@ -361,28 +347,8 @@ and [<StructuralEquality; StructuralComparison>]
/// Actual generic parameters are always types.


and ILGenericArgs = ILList<ILType>
and ILTypes = ILList<ILType>


[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module ILList =
val inline map : ('T -> 'U) -> ILList<'T> -> ILList<'U>
val inline mapi : (int -> 'T -> 'U) -> ILList<'T> -> ILList<'U>
val inline isEmpty : ILList<'T> -> bool
val inline toList : ILList<'T> -> 'T list
val inline ofList : 'T list -> ILList<'T>
val inline lengthsEqAndForall2 : ('T -> 'U -> bool) -> ILList<'T> -> ILList<'U> -> bool
val inline init : int -> (int -> 'T) -> ILList<'T>
val inline empty<'T> : ILList<'T>
val inline toArray : ILList<'T> -> 'T[]
val inline ofArray : 'T[] -> ILList<'T>
val inline nth : ILList<'T> -> int -> 'T
val inline iter : ('T -> unit) -> ILList<'T> -> unit
val inline iteri : (int -> 'T -> unit) -> ILList<'T> -> unit
val inline foldBack : ('T -> 'State -> 'State) -> ILList<'T> -> 'State -> 'State
val inline exists : ('T -> bool) -> ILList<'T> -> bool

and ILGenericArgs = list<ILType>
and ILTypes = list<ILType>

/// Formal identities of methods. Method refs refer to methods on
/// named types. In general you should work with ILMethodSpec objects
Expand Down Expand Up @@ -817,8 +783,7 @@ type ILLocal =
IsPinned: bool;
DebugInfo: (string * int * int) option }


type ILLocals = ILList<ILLocal>
type ILLocals = list<ILLocal>

/// IL method bodies
[<RequireQualifiedAccess; NoComparison; NoEquality>]
Expand Down Expand Up @@ -891,10 +856,9 @@ type ILParameter =
IsOptional: bool;
CustomAttrs: ILAttributes }

type ILParameters = ILList<ILParameter>
type ILParameters = list<ILParameter>

val typesOfILParamsRaw : ILParameters -> ILTypes
val typesOfILParamsList : ILParameter list -> ILType list
val typesOfILParams : ILParameters -> ILType list

/// Method return values.
[<RequireQualifiedAccess; NoEquality; NoComparison>]
Expand Down Expand Up @@ -1658,7 +1622,6 @@ val decodeILAttribData:
val mkSimpleAssRef: string -> ILAssemblyRef
val mkSimpleModRef: string -> ILModuleRef

val emptyILGenericArgs: ILGenericArgs
val mkILTyvarTy: uint16 -> ILType

/// Make type refs.
Expand All @@ -1667,18 +1630,15 @@ val mkILTyRef: ILScopeRef * string -> ILTypeRef
val mkILTyRefInTyRef: ILTypeRef * string -> ILTypeRef

type ILGenericArgsList = ILType list
val mkILGenericArgs : ILGenericArgsList -> ILGenericArgs

/// Make type specs.
val mkILNonGenericTySpec: ILTypeRef -> ILTypeSpec
val mkILTySpec: ILTypeRef * ILGenericArgsList -> ILTypeSpec
val mkILTySpecRaw: ILTypeRef * ILGenericArgs -> ILTypeSpec

/// Make types.
val mkILTy: ILBoxity -> ILTypeSpec -> ILType
val mkILNamedTy: ILBoxity -> ILTypeRef -> ILGenericArgsList -> ILType
val mkILNamedTyRaw: ILBoxity -> ILTypeRef -> ILGenericArgs -> ILType
val mkILBoxedTy: ILTypeRef -> ILGenericArgsList -> ILType
val mkILBoxedTyRaw: ILTypeRef -> ILGenericArgs -> ILType
val mkILValueTy: ILTypeRef -> ILGenericArgsList -> ILType
val mkILNonGenericBoxedTy: ILTypeRef -> ILType
val mkILNonGenericValueTy: ILTypeRef -> ILType
Expand All @@ -1688,16 +1648,11 @@ val isILArrTy: ILType -> bool
val destILArrTy: ILType -> ILArrayShape * ILType
val mkILBoxedType : ILTypeSpec -> ILType

val mkILTypes : ILType list -> ILTypes

/// Make method references and specs.
val mkILMethRefRaw: ILTypeRef * ILCallingConv * string * int * ILTypes * ILType -> ILMethodRef
val mkILMethRef: ILTypeRef * ILCallingConv * string * int * ILType list * ILType -> ILMethodRef
val mkILMethSpec: ILMethodRef * ILBoxity * ILGenericArgsList * ILGenericArgsList -> ILMethodSpec
val mkILMethSpecForMethRefInTyRaw: ILMethodRef * ILType * ILGenericArgs -> ILMethodSpec
val mkILMethSpecForMethRefInTy: ILMethodRef * ILType * ILGenericArgsList -> ILMethodSpec
val mkILMethSpecInTy: ILType * ILCallingConv * string * ILType list * ILType * ILGenericArgsList -> ILMethodSpec
val mkILMethSpecInTyRaw: ILType * ILCallingConv * string * ILTypes * ILType * ILGenericArgs -> ILMethodSpec

/// Construct references to methods on a given type .
val mkILNonGenericMethSpecInTy: ILType * ILCallingConv * string * ILType list * ILType -> ILMethodSpec
Expand All @@ -1722,17 +1677,14 @@ val mkILFieldRef: ILTypeRef * string * ILType -> ILFieldRef
val mkILFieldSpec: ILFieldRef * ILType -> ILFieldSpec
val mkILFieldSpecInTy: ILType * string * ILType -> ILFieldSpec

val mkILCallSigRaw: ILCallingConv * ILTypes * ILType -> ILCallingSignature
val mkILCallSig: ILCallingConv * ILType list * ILType -> ILCallingSignature

/// Make generalized verions of possibly-generic types,
/// e.g. Given the ILTypeDef for List, return the type "List<T>".
val mkILFormalBoxedTy: ILTypeRef -> ILGenericParameterDef list -> ILType
val mkILFormalNamedTy: ILBoxity -> ILTypeRef -> ILGenericParameterDef list -> ILType

val mkILFormalTyparsRaw: ILTypes -> ILGenericParameterDefs
val mkILFormalTypars: ILType list -> ILGenericParameterDefs
val mkILFormalGenericArgsRaw: ILGenericParameterDefs -> ILGenericArgs
val mkILFormalGenericArgs: ILGenericParameterDefs -> ILGenericArgsList
val mkILSimpleTypar : string -> ILGenericParameterDef
/// Make custom attributes.
Expand Down Expand Up @@ -1794,8 +1746,6 @@ val mkILParamAnon: ILType -> ILParameter
val mkILParamNamed: string * ILType -> ILParameter
val mkILReturn: ILType -> ILReturn
val mkILLocal: ILType -> (string * int * int) option -> ILLocal
val mkILLocals : ILLocal list -> ILLocals
val emptyILLocals : ILLocals

/// Make a formal generic parameters.
val mkILEmptyGenericParams: ILGenericParameterDefs
Expand Down
59 changes: 0 additions & 59 deletions src/absil/illib.fs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -483,64 +483,6 @@ module ResultOrException =
| Result x -> success x
| Exception _err -> f()


//-------------------------------------------------------------------------
// Library: extensions to flat list (immutable arrays)
//------------------------------------------------------------------------
#if FLAT_LIST_AS_ARRAY_STRUCT
//#else
module FlatList =

let order (eltOrder: IComparer<_>) =
{ new IComparer<FlatList<_>> with
member __.Compare(xs,ys) =
match xs.array,ys.array with
| null,null -> 0
| _,null -> 1
| null,_ -> -1
| arr1,arr2 -> Array.order eltOrder arr1 arr2 }

let mapq f (x:FlatList<_>) =
match x.array with
| null -> x
| arr ->
let arr' = Array.map f arr in
let n = arr.Length in
let rec check i = if i >= n then true else arr.[i] === arr'.[i] && check (i+1)
if check 0 then x else FlatList(arr')

let mapFold f acc (x:FlatList<_>) =
match x.array with
| null ->
FlatList.Empty,acc
| arr ->
let arr,acc = Array.mapFold f acc x.array
FlatList(arr),acc

#endif
#if FLAT_LIST_AS_LIST

#else

module FlatList =
let toArray xs = List.toArray xs
let choose f xs = List.choose f xs
let order eltOrder = List.order eltOrder
let mapq f (x:FlatList<_>) = List.mapq f x
let mapFold f acc (x:FlatList<_>) = List.mapFold f acc x

#endif

#if FLAT_LIST_AS_ARRAY
//#else
module FlatList =
let order eltOrder = Array.order eltOrder
let mapq f x = Array.mapq f x
let mapFold f acc x = Array.mapFold f acc x
#endif



/// Computations that can cooperatively yield by returning a continuation
///
/// - Any yield of a NotYetDone should typically be "abandonable" without adverse consequences. No resource release
Expand Down Expand Up @@ -781,7 +723,6 @@ module NameMap =
let ofKeyedList f l = List.foldBack (fun x acc -> Map.add (f x) x acc) l Map.empty
let ofList l : NameMap<'T> = Map.ofList l
let ofSeq l : NameMap<'T> = Map.ofSeq l
let ofFlatList (l:FlatList<_>) : NameMap<'T> = FlatList.toMap l
let toList (l: NameMap<'T>) = Map.toList l
let layer (m1 : NameMap<'T>) m2 = Map.foldBack Map.add m1 m2

Expand Down
32 changes: 16 additions & 16 deletions src/absil/ilmorph.fs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -55,7 +55,7 @@ let rec typ_tref2tref f x =
| ILType.FunctionPointer x ->
ILType.FunctionPointer
{ x with
ArgTypes=ILList.map (typ_tref2tref f) x.ArgTypes;
ArgTypes=List.map (typ_tref2tref f) x.ArgTypes;
ReturnType=typ_tref2tref f x.ReturnType}
| ILType.Byref t -> ILType.Byref (typ_tref2tref f t)
| ILType.Boxed cr -> mkILBoxedType (tspec_tref2tref f cr)
Expand All @@ -65,7 +65,7 @@ let rec typ_tref2tref f x =
| ILType.Modified (req,tref,ty) -> ILType.Modified (req, f tref, typ_tref2tref f ty)
| ILType.Void -> ILType.Void
and tspec_tref2tref f (x:ILTypeSpec) =
mkILTySpecRaw(f x.TypeRef, ILList.map (typ_tref2tref f) x.GenericArgs)
mkILTySpec(f x.TypeRef, List.map (typ_tref2tref f) x.GenericArgs)

let rec typ_scoref2scoref_tyvar2typ ((_fscope,ftyvar) as fs)x =
match x with
Expand All @@ -81,9 +81,9 @@ and tspec_scoref2scoref_tyvar2typ fs (x:ILTypeSpec) =
ILTypeSpec.Create(morphILScopeRefsInILTypeRef (fst fs) x.TypeRef,typs_scoref2scoref_tyvar2typ fs x.GenericArgs)
and callsig_scoref2scoref_tyvar2typ f x =
{ x with
ArgTypes=ILList.map (typ_scoref2scoref_tyvar2typ f) x.ArgTypes;
ArgTypes=List.map (typ_scoref2scoref_tyvar2typ f) x.ArgTypes;
ReturnType=typ_scoref2scoref_tyvar2typ f x.ReturnType}
and typs_scoref2scoref_tyvar2typ f i = ILList.map (typ_scoref2scoref_tyvar2typ f) i
and typs_scoref2scoref_tyvar2typ f i = List.map (typ_scoref2scoref_tyvar2typ f) i
and gparams_scoref2scoref_tyvar2typ f i = List.map (gparam_scoref2scoref_tyvar2typ f) i
and gparam_scoref2scoref_tyvar2typ _f i = i
and morphILScopeRefsInILTypeRef fscope (x:ILTypeRef) =
Expand All @@ -92,27 +92,27 @@ and morphILScopeRefsInILTypeRef fscope (x:ILTypeRef) =

let callsig_typ2typ f (x: ILCallingSignature) =
{ CallingConv=x.CallingConv;
ArgTypes=ILList.map f x.ArgTypes;
ArgTypes=List.map f x.ArgTypes;
ReturnType=f x.ReturnType}

let gparam_typ2typ f gf = {gf with Constraints = ILList.map f gf.Constraints}
let gparam_typ2typ f gf = {gf with Constraints = List.map f gf.Constraints}
let gparams_typ2typ f gfs = List.map (gparam_typ2typ f) gfs
let typs_typ2typ (f: ILType -> ILType) x = ILList.map f x
let typs_typ2typ (f: ILType -> ILType) x = List.map f x
let mref_typ2typ (f: ILType -> ILType) (x:ILMethodRef) =
ILMethodRef.Create(enclosingTypeRef= (f (mkILBoxedType (mkILNonGenericTySpec x.EnclosingTypeRef))).TypeRef,
callingConv=x.CallingConv,
name=x.Name,
genericArity=x.GenericArity,
argTypes= ILList.map f x.ArgTypes,
argTypes= List.map f x.ArgTypes,
returnType= f x.ReturnType)


type formal_scopeCtxt = Choice<ILMethodSpec, ILFieldSpec>

let mspec_typ2typ (((factualty : ILType -> ILType) , (fformalty: formal_scopeCtxt -> ILType -> ILType))) (x: ILMethodSpec) =
mkILMethSpecForMethRefInTyRaw(mref_typ2typ (fformalty (Choice1Of2 x)) x.MethodRef,
factualty x.EnclosingType,
typs_typ2typ factualty x.GenericArgs)
mkILMethSpecForMethRefInTy(mref_typ2typ (fformalty (Choice1Of2 x)) x.MethodRef,
factualty x.EnclosingType,
typs_typ2typ factualty x.GenericArgs)

let fref_typ2typ (f: ILType -> ILType) x =
{ x with EnclosingTypeRef = (f (mkILBoxedType (mkILNonGenericTySpec x.EnclosingTypeRef))).TypeRef;
Expand Down Expand Up @@ -155,7 +155,7 @@ let fdef_typ2typ ilg ftype (fd: ILFieldDef) =
CustomAttrs=cattrs_typ2typ ilg ftype fd.CustomAttrs}

let local_typ2typ f (l: ILLocal) = {l with Type = f l.Type}
let varargs_typ2typ f (varargs: ILVarArgs) = Option.map (ILList.map f) varargs
let varargs_typ2typ f (varargs: ILVarArgs) = Option.map (List.map f) varargs
(* REVIEW: convert varargs *)
let morphILTypesInILInstr ((factualty,fformalty)) i =
let factualty = factualty (Some i)
Expand Down Expand Up @@ -205,7 +205,7 @@ let fdefs_fdef2fdef f (m:ILFieldDefs) = mkILFields (List.map f m.AsList)
(* use this when the conversion produces just one type... *)
let morphILTypeDefs f (m: ILTypeDefs) = mkILTypeDefsFromArray (Array.map f m.AsArray)

let locals_typ2typ f ls = ILList.map (local_typ2typ f) ls
let locals_typ2typ f ls = List.map (local_typ2typ f) ls

let ilmbody_instr2instr_typ2typ fs (il: ILMethodBody) =
let (finstr,ftype) = fs
Expand All @@ -228,7 +228,7 @@ let mdef_typ2typ_ilmbody2ilmbody ilg fs md =
{md with
GenericParams=gparams_typ2typ ftype' md.GenericParams;
mdBody= body';
Parameters = ILList.map (param_typ2typ ilg ftype') md.Parameters;
Parameters = List.map (param_typ2typ ilg ftype') md.Parameters;
Return = return_typ2typ ilg ftype' md.Return;
CustomAttrs=cattrs_typ2typ ilg ftype' md.CustomAttrs }

Expand All @@ -254,7 +254,7 @@ let pdef_typ2typ ilg f p =
SetMethod = Option.map (mref_typ2typ f) p.SetMethod;
GetMethod = Option.map (mref_typ2typ f) p.GetMethod;
Type = f p.Type;
Args = ILList.map f p.Args;
Args = List.map f p.Args;
CustomAttrs = cattrs_typ2typ ilg f p.CustomAttrs }

let pdefs_typ2typ ilg f (pdefs: ILPropertyDefs) = mkILProperties (List.map (pdef_typ2typ ilg f) pdefs.AsList)
Expand All @@ -267,7 +267,7 @@ let rec tdef_typ2typ_ilmbody2ilmbody_mdefs2mdefs ilg enc fs td =
let ftype' = ftype (Some (enc,td)) None
let mdefs' = fmdefs (enc,td) td.Methods
let fdefs' = fdefs_typ2typ ilg ftype' td.Fields
{td with Implements= ILList.map ftype' td.Implements;
{td with Implements= List.map ftype' td.Implements;
GenericParams= gparams_typ2typ ftype' td.GenericParams;
Extends = Option.map ftype' td.Extends;
Methods=mdefs';
Expand Down
4 changes: 2 additions & 2 deletions src/absil/ilpars.fsy
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@ type SigArg = SigArg of (string option * ILType) | Sentinel
let decodeVarargs args =
let rec normals = function
| [] -> ([],None)
| Sentinel :: t -> ([],Some (ILList.ofList (varargs t)))
| Sentinel :: t -> ([],Some (varargs t))
| SigArg (_,p)::t -> let (n,r) = normals t in (p::n, r)
and varargs = function
| [] -> []
Expand All @@ -46,7 +46,7 @@ let resolveMethodSpecScopeThen (ResolvedAtMethodSpecScope f) g =
let resolveFormalMethodSpecScope tspeco obj =
match tspeco with
None -> resolveMethodSpecScope obj mkILEmptyGenericParams
| Some (tspec:ILTypeSpec) -> resolveMethodSpecScope obj (mkILFormalTyparsRaw tspec.GenericArgs)
| Some (tspec:ILTypeSpec) -> resolveMethodSpecScope obj (mkILFormalTypars tspec.GenericArgs)

let resolveCurrentMethodSpecScope obj =
resolveMethodSpecScope obj mkILEmptyGenericParams
Expand Down
8 changes: 4 additions & 4 deletions src/absil/ilprint.fs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -208,7 +208,7 @@ and goutput_ldtoken_info env os = function
| ILToken.ILField x -> output_string os "field "; goutput_fspec env os x

and goutput_typ_with_shortened_class_syntax env os = function
ILType.Boxed tspec when tspec.GenericArgs = emptyILGenericArgs ->
ILType.Boxed tspec when tspec.GenericArgs = [] ->
goutput_tref env os tspec.TypeRef
| typ2 -> goutput_typ env os typ2

Expand Down Expand Up @@ -339,7 +339,7 @@ and goutput_mref env os (mref:ILMethodRef) =
and goutput_mspec env os (mspec:ILMethodSpec) =
let fenv =
ppenv_enter_method mspec.GenericArity
(ppenv_enter_tdef (mkILFormalTyparsRaw mspec.EnclosingType.GenericArgs) env)
(ppenv_enter_tdef (mkILFormalTypars mspec.EnclosingType.GenericArgs) env)
output_callconv os mspec.CallingConv;
output_string os " ";
goutput_typ fenv os mspec.FormalReturnType;
Expand All @@ -357,7 +357,7 @@ and goutput_vararg_mspec env os (mspec, varargs) =
| Some varargs' ->
let fenv =
ppenv_enter_method mspec.GenericArity
(ppenv_enter_tdef (mkILFormalTyparsRaw mspec.EnclosingType.GenericArgs) env)
(ppenv_enter_tdef (mkILFormalTypars mspec.EnclosingType.GenericArgs) env)
output_callconv os mspec.CallingConv;
output_string os " ";
goutput_typ fenv os mspec.FormalReturnType;
Expand Down Expand Up @@ -386,7 +386,7 @@ and goutput_vararg_sig env os (csig:ILCallingSignature,varargs:ILVarArgs) =
output_string os ")";

and goutput_fspec env os (x:ILFieldSpec) =
let fenv = ppenv_enter_tdef (mkILFormalTyparsRaw x.EnclosingType.GenericArgs) env
let fenv = ppenv_enter_tdef (mkILFormalTypars x.EnclosingType.GenericArgs) env
goutput_typ fenv os x.FormalType;
output_string os " ";
goutput_dlocref env os x.EnclosingType;
Expand Down
Loading