From 3465ffcd2a61c41fee81e957e6bb64d5ab68ef8b Mon Sep 17 00:00:00 2001 From: "graydon@pobox.com" Date: Tue, 15 Apr 2008 18:23:34 -0700 Subject: [PATCH] axe a couple extra uses of dead types in builtins, regenerate pretty-cvt --HG-- branch : com.mozilla.es4.smlnj extra : convert_revision : 632690f4ae00569b24e7a7f8284af412fd52a451 --- builtins/Array.es | 2 +- builtins/double.es | 2 +- pretty-cvt.sml | 1114 ++++++++++++++++++++++---------------------- 3 files changed, 558 insertions(+), 560 deletions(-) diff --git a/builtins/Array.es b/builtins/Array.es index a65288cd..d9fb8df3 100644 --- a/builtins/Array.es +++ b/builtins/Array.es @@ -689,7 +689,7 @@ package // Then clamp it between 0 and len inclusive, and convert it to uint. // // Also used by Vector.es - helper function clamp(val: AnyNumber, len: double): uint { + helper function clamp(val: AnyNumber, len: double): double { val = helper::toInteger(val); if (val < 0) val += len; diff --git a/builtins/double.es b/builtins/double.es index 0744b681..e44ac5c6 100644 --- a/builtins/double.es +++ b/builtins/double.es @@ -145,7 +145,7 @@ package x must be positive, f is in the range [0,20]. */ // FIXME: really informative, not intrinsic - native intrinsic function toFixedStep10(x : (double|decimal), f : double) : int; + native intrinsic function toFixedStep10(x : (double|decimal), f : double) : double; intrinsic function toExponential(fractionDigits=undefined) : string { return "**toExponential: FIXME**"; diff --git a/pretty-cvt.sml b/pretty-cvt.sml index d964779f..f505f295 100644 --- a/pretty-cvt.sml +++ b/pretty-cvt.sml @@ -97,649 +97,647 @@ structure PrettyCvt = struct and cvtPRAGMA (UseNamespace x129) = PrettyRep.Ctor ("UseNamespace", SOME (cvtEXPR x129)) | cvtPRAGMA (UseDefaultNamespace x132) = PrettyRep.Ctor ("UseDefaultNamespace", SOME (cvtEXPR x132)) - | cvtPRAGMA (UseDecimalContext x135) = PrettyRep.Ctor ("UseDecimalContext", - SOME (cvtEXPR x135)) | cvtPRAGMA (UseStrict) = PrettyRep.Ctor ("UseStrict", NONE) | cvtPRAGMA (UseStandard) = PrettyRep.Ctor ("UseStandard", NONE) - | cvtPRAGMA (Import{package=ls141, name=x145}) = PrettyRep.Ctor ("Import", - SOME (PrettyRep.Rec [("package", PrettyRep.List (List.map (fn x140 => - cvtIDENT x140 - ) ls141)), - ("name", cvtIDENT x145)])) + | cvtPRAGMA (Import{package=ls138, name=x142}) = PrettyRep.Ctor ("Import", + SOME (PrettyRep.Rec [("package", PrettyRep.List (List.map (fn x137 => + cvtIDENT x137 + ) ls138)), + ("name", cvtIDENT x142)])) and cvtFUNC_NAME_KIND (Ordinary) = PrettyRep.Ctor ("Ordinary", NONE) | cvtFUNC_NAME_KIND (Operator) = PrettyRep.Ctor ("Operator", NONE) | cvtFUNC_NAME_KIND (Get) = PrettyRep.Ctor ("Get", NONE) | cvtFUNC_NAME_KIND (Set) = PrettyRep.Ctor ("Set", NONE) | cvtFUNC_NAME_KIND (Call) = PrettyRep.Ctor ("Call", NONE) | cvtFUNC_NAME_KIND (Has) = PrettyRep.Ctor ("Has", NONE) - and cvtTY (Ty{expr=x159, ribId=opt161}) = PrettyRep.Ctor ("Ty", SOME (PrettyRep.Rec [("expr", - cvtTYPE_EXPR x159), ("ribId", - (case opt161 of + and cvtTY (Ty{expr=x156, ribId=opt158}) = PrettyRep.Ctor ("Ty", SOME (PrettyRep.Rec [("expr", + cvtTYPE_EXPR x156), ("ribId", + (case opt158 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x160 => PrettyRep.Ctor ("SOME", SOME (cvtRIB_ID x160)) + | SOME x157 => PrettyRep.Ctor ("SOME", SOME (cvtRIB_ID x157)) ))])) - and cvtCLS (Cls{name=x172, typeParams=ls174, nonnullable=b178, dynamic=b179, - extends=opt181, implements=ls186, classRib=x190, instanceRib=x191, - instanceInits=x192, constructor=opt194, classType=x198, instanceType=x199}) = - PrettyRep.Ctor ("Cls", SOME (PrettyRep.Rec [("name", cvtNAME x172), - ("typeParams", PrettyRep.List (List.map (fn x173 => cvtIDENT x173 - ) ls174)), ("nonnullable", - PrettyRep.Bool b178), ("dynamic", PrettyRep.Bool b179), ("extends", + and cvtCLS (Cls{name=x169, typeParams=ls171, nonnullable=b175, dynamic=b176, + extends=opt178, implements=ls183, classRib=x187, instanceRib=x188, + instanceInits=x189, constructor=opt191, classType=x195, instanceType=x196}) = + PrettyRep.Ctor ("Cls", SOME (PrettyRep.Rec [("name", cvtNAME x169), + ("typeParams", PrettyRep.List (List.map (fn x170 => cvtIDENT x170 + ) ls171)), ("nonnullable", + PrettyRep.Bool b175), ("dynamic", PrettyRep.Bool b176), ("extends", - (case opt181 of + (case opt178 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x180 => PrettyRep.Ctor ("SOME", SOME (cvtTY x180)) - )), ("implements", PrettyRep.List (List.map (fn x185 => cvtTY x185 - ) ls186)), ("classRib", - cvtRIB x190), ("instanceRib", cvtRIB x191), ("instanceInits", cvtHEAD x192), + | SOME x177 => PrettyRep.Ctor ("SOME", SOME (cvtTY x177)) + )), ("implements", PrettyRep.List (List.map (fn x182 => cvtTY x182 + ) ls183)), ("classRib", + cvtRIB x187), ("instanceRib", cvtRIB x188), ("instanceInits", cvtHEAD x189), ("constructor", - (case opt194 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x193 => PrettyRep.Ctor ("SOME", SOME (cvtCTOR x193)) - )), ("classType", cvtTY x198), ("instanceType", cvtTY x199)])) - and cvtIFACE (Iface{name=x227, typeParams=ls229, nonnullable=b233, extends=ls235, - instanceRib=x239, instanceType=x240}) = PrettyRep.Ctor ("Iface", - SOME (PrettyRep.Rec [("name", cvtNAME x227), ("typeParams", PrettyRep.List (List.map (fn x228 => - cvtIDENT x228 - ) ls229)), - ("nonnullable", PrettyRep.Bool b233), ("extends", PrettyRep.List (List.map (fn x234 => - cvtTY x234 - ) ls235)), - ("instanceRib", cvtRIB x239), ("instanceType", cvtTY x240)])) - and cvtCTOR (Ctor{settings=x256, superArgs=ls258, func=x262}) = PrettyRep.Ctor ("Ctor", - SOME (PrettyRep.Rec [("settings", cvtHEAD x256), ("superArgs", PrettyRep.List (List.map (fn x257 => - cvtEXPR x257 - ) ls258)), - ("func", cvtFUNC x262)])) - and cvtFUNC (Func{name=x272, fsig=x273, native=b274, block=opt276, param=x280, - defaults=ls282, ty=x286, loc=opt288}) = PrettyRep.Ctor ("Func", SOME (PrettyRep.Rec [("name", - cvtFUNC_NAME x272), ("fsig", cvtFUNC_SIG x273), ("native", PrettyRep.Bool b274), + (case opt191 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x190 => PrettyRep.Ctor ("SOME", SOME (cvtCTOR x190)) + )), ("classType", cvtTY x195), ("instanceType", cvtTY x196)])) + and cvtIFACE (Iface{name=x224, typeParams=ls226, nonnullable=b230, extends=ls232, + instanceRib=x236, instanceType=x237}) = PrettyRep.Ctor ("Iface", + SOME (PrettyRep.Rec [("name", cvtNAME x224), ("typeParams", PrettyRep.List (List.map (fn x225 => + cvtIDENT x225 + ) ls226)), + ("nonnullable", PrettyRep.Bool b230), ("extends", PrettyRep.List (List.map (fn x231 => + cvtTY x231 + ) ls232)), + ("instanceRib", cvtRIB x236), ("instanceType", cvtTY x237)])) + and cvtCTOR (Ctor{settings=x253, superArgs=ls255, func=x259}) = PrettyRep.Ctor ("Ctor", + SOME (PrettyRep.Rec [("settings", cvtHEAD x253), ("superArgs", PrettyRep.List (List.map (fn x254 => + cvtEXPR x254 + ) ls255)), + ("func", cvtFUNC x259)])) + and cvtFUNC (Func{name=x269, fsig=x270, native=b271, block=opt273, param=x277, + defaults=ls279, ty=x283, loc=opt285}) = PrettyRep.Ctor ("Func", SOME (PrettyRep.Rec [("name", + cvtFUNC_NAME x269), ("fsig", cvtFUNC_SIG x270), ("native", PrettyRep.Bool b271), ("block", - (case opt276 of + (case opt273 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x275 => PrettyRep.Ctor ("SOME", SOME (cvtBLOCK x275)) - )), ("param", cvtHEAD x280), ("defaults", PrettyRep.List (List.map (fn x281 => - cvtEXPR x281 - ) ls282)), - ("ty", cvtTY x286), ("loc", - (case opt288 of + | SOME x272 => PrettyRep.Ctor ("SOME", SOME (cvtBLOCK x272)) + )), ("param", cvtHEAD x277), ("defaults", PrettyRep.List (List.map (fn x278 => + cvtEXPR x278 + ) ls279)), + ("ty", cvtTY x283), ("loc", + (case opt285 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x287 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x287)) + | SOME x284 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x284)) ))])) - and cvtDEFN (ClassDefn x311) = PrettyRep.Ctor ("ClassDefn", SOME (cvtCLASS_DEFN x311)) - | cvtDEFN (VariableDefn x314) = PrettyRep.Ctor ("VariableDefn", SOME (cvtVAR_DEFN x314)) - | cvtDEFN (FunctionDefn x317) = PrettyRep.Ctor ("FunctionDefn", SOME (cvtFUNC_DEFN x317)) - | cvtDEFN (ConstructorDefn x320) = PrettyRep.Ctor ("ConstructorDefn", - SOME (cvtCTOR_DEFN x320)) - | cvtDEFN (InterfaceDefn x323) = PrettyRep.Ctor ("InterfaceDefn", SOME (cvtINTERFACE_DEFN x323)) - | cvtDEFN (NamespaceDefn x326) = PrettyRep.Ctor ("NamespaceDefn", SOME (cvtNAMESPACE_DEFN x326)) - | cvtDEFN (TypeDefn x329) = PrettyRep.Ctor ("TypeDefn", SOME (cvtTYPE_DEFN x329)) - and cvtFUNC_SIG (FunctionSignature{typeParams=ls333, params=x337, paramTypes=ls339, - defaults=ls344, ctorInits=opt355, returnType=x359, thisType=opt361, - hasRest=b365}) = PrettyRep.Ctor ("FunctionSignature", SOME (PrettyRep.Rec [("typeParams", - PrettyRep.List (List.map (fn x332 => cvtIDENT x332 - ) ls333)), ("params", cvtBINDINGS x337), - ("paramTypes", PrettyRep.List (List.map (fn x338 => cvtTYPE_EXPR x338 - ) ls339)), ("defaults", PrettyRep.List (List.map (fn x343 => - cvtEXPR x343 - ) ls344)), + and cvtDEFN (ClassDefn x308) = PrettyRep.Ctor ("ClassDefn", SOME (cvtCLASS_DEFN x308)) + | cvtDEFN (VariableDefn x311) = PrettyRep.Ctor ("VariableDefn", SOME (cvtVAR_DEFN x311)) + | cvtDEFN (FunctionDefn x314) = PrettyRep.Ctor ("FunctionDefn", SOME (cvtFUNC_DEFN x314)) + | cvtDEFN (ConstructorDefn x317) = PrettyRep.Ctor ("ConstructorDefn", + SOME (cvtCTOR_DEFN x317)) + | cvtDEFN (InterfaceDefn x320) = PrettyRep.Ctor ("InterfaceDefn", SOME (cvtINTERFACE_DEFN x320)) + | cvtDEFN (NamespaceDefn x323) = PrettyRep.Ctor ("NamespaceDefn", SOME (cvtNAMESPACE_DEFN x323)) + | cvtDEFN (TypeDefn x326) = PrettyRep.Ctor ("TypeDefn", SOME (cvtTYPE_DEFN x326)) + and cvtFUNC_SIG (FunctionSignature{typeParams=ls330, params=x334, paramTypes=ls336, + defaults=ls341, ctorInits=opt352, returnType=x356, thisType=opt358, + hasRest=b362}) = PrettyRep.Ctor ("FunctionSignature", SOME (PrettyRep.Rec [("typeParams", + PrettyRep.List (List.map (fn x329 => cvtIDENT x329 + ) ls330)), ("params", cvtBINDINGS x334), + ("paramTypes", PrettyRep.List (List.map (fn x335 => cvtTYPE_EXPR x335 + ) ls336)), ("defaults", PrettyRep.List (List.map (fn x340 => + cvtEXPR x340 + ) ls341)), ("ctorInits", - (case opt355 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME(x348, ls350) => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Tuple [cvtBINDINGS x348, - PrettyRep.List (List.map (fn x349 => cvtEXPR x349 - ) ls350)])) - )), ("returnType", cvtTYPE_EXPR x359), ("thisType", - (case opt361 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x360 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x360)) - )), ("hasRest", PrettyRep.Bool b365)])) - and cvtBINDING (Binding{ident=x385, ty=x386}) = PrettyRep.Ctor ("Binding", - SOME (PrettyRep.Rec [("ident", cvtBINDING_IDENT x385), ("ty", cvtTYPE_EXPR x386)])) - and cvtBINDING_IDENT (TempIdent n394) = PrettyRep.Ctor ("TempIdent", SOME (PrettyRep.Int n394)) - | cvtBINDING_IDENT (ParamIdent n397) = PrettyRep.Ctor ("ParamIdent", SOME (PrettyRep.Int n397)) - | cvtBINDING_IDENT (PropIdent x400) = PrettyRep.Ctor ("PropIdent", SOME (cvtIDENT x400)) - and cvtINIT_STEP (InitStep(x403, x404)) = PrettyRep.Ctor ("InitStep", SOME (PrettyRep.Tuple [cvtBINDING_IDENT x403, - cvtEXPR x404])) - | cvtINIT_STEP (AssignStep(x408, x409)) = PrettyRep.Ctor ("AssignStep", - SOME (PrettyRep.Tuple [cvtEXPR x408, cvtEXPR x409])) - and cvtTYPE_EXPR (SpecialType x413) = PrettyRep.Ctor ("SpecialType", SOME (cvtSPECIAL_TY x413)) - | cvtTYPE_EXPR (UnionType ls417) = PrettyRep.Ctor ("UnionType", SOME (PrettyRep.List (List.map (fn x416 => - cvtTYPE_EXPR x416 - ) ls417))) - | cvtTYPE_EXPR (ArrayType ls424) = PrettyRep.Ctor ("ArrayType", SOME (PrettyRep.List (List.map (fn x423 => - cvtTYPE_EXPR x423 - ) ls424))) - | cvtTYPE_EXPR (TypeName x430) = PrettyRep.Ctor ("TypeName", SOME (cvtIDENT_EXPR x430)) - | cvtTYPE_EXPR (ElementTypeRef(x433, n434)) = PrettyRep.Ctor ("ElementTypeRef", - SOME (PrettyRep.Tuple [cvtTYPE_EXPR x433, PrettyRep.Int n434])) - | cvtTYPE_EXPR (FieldTypeRef(x438, x439)) = PrettyRep.Ctor ("FieldTypeRef", - SOME (PrettyRep.Tuple [cvtTYPE_EXPR x438, cvtIDENT x439])) - | cvtTYPE_EXPR (FunctionType x443) = PrettyRep.Ctor ("FunctionType", SOME (cvtFUNC_TYPE x443)) - | cvtTYPE_EXPR (ObjectType ls447) = PrettyRep.Ctor ("ObjectType", SOME (PrettyRep.List (List.map (fn x446 => - cvtFIELD_TYPE x446 - ) ls447))) - | cvtTYPE_EXPR (LikeType x453) = PrettyRep.Ctor ("LikeType", SOME (cvtTYPE_EXPR x453)) - | cvtTYPE_EXPR (AppType{base=x456, args=ls458}) = PrettyRep.Ctor ("AppType", - SOME (PrettyRep.Rec [("base", cvtTYPE_EXPR x456), ("args", PrettyRep.List (List.map (fn x457 => - cvtTYPE_EXPR x457 - ) ls458))])) - | cvtTYPE_EXPR (LamType{params=ls470, body=x474}) = PrettyRep.Ctor ("LamType", - SOME (PrettyRep.Rec [("params", PrettyRep.List (List.map (fn x469 => - cvtIDENT x469 - ) ls470)), - ("body", cvtTYPE_EXPR x474)])) - | cvtTYPE_EXPR (NullableType{expr=x482, nullable=b483}) = PrettyRep.Ctor ("NullableType", - SOME (PrettyRep.Rec [("expr", cvtTYPE_EXPR x482), ("nullable", PrettyRep.Bool b483)])) - | cvtTYPE_EXPR (InstanceType x491) = PrettyRep.Ctor ("InstanceType", SOME (cvtINSTANCE_TYPE x491)) + (case opt352 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME(x345, ls347) => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Tuple [cvtBINDINGS x345, + PrettyRep.List (List.map (fn x346 => cvtEXPR x346 + ) ls347)])) + )), ("returnType", cvtTYPE_EXPR x356), ("thisType", + (case opt358 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x357 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x357)) + )), ("hasRest", PrettyRep.Bool b362)])) + and cvtBINDING (Binding{ident=x382, ty=x383}) = PrettyRep.Ctor ("Binding", + SOME (PrettyRep.Rec [("ident", cvtBINDING_IDENT x382), ("ty", cvtTYPE_EXPR x383)])) + and cvtBINDING_IDENT (TempIdent n391) = PrettyRep.Ctor ("TempIdent", SOME (PrettyRep.Int n391)) + | cvtBINDING_IDENT (ParamIdent n394) = PrettyRep.Ctor ("ParamIdent", SOME (PrettyRep.Int n394)) + | cvtBINDING_IDENT (PropIdent x397) = PrettyRep.Ctor ("PropIdent", SOME (cvtIDENT x397)) + and cvtINIT_STEP (InitStep(x400, x401)) = PrettyRep.Ctor ("InitStep", SOME (PrettyRep.Tuple [cvtBINDING_IDENT x400, + cvtEXPR x401])) + | cvtINIT_STEP (AssignStep(x405, x406)) = PrettyRep.Ctor ("AssignStep", + SOME (PrettyRep.Tuple [cvtEXPR x405, cvtEXPR x406])) + and cvtTYPE_EXPR (SpecialType x410) = PrettyRep.Ctor ("SpecialType", SOME (cvtSPECIAL_TY x410)) + | cvtTYPE_EXPR (UnionType ls414) = PrettyRep.Ctor ("UnionType", SOME (PrettyRep.List (List.map (fn x413 => + cvtTYPE_EXPR x413 + ) ls414))) + | cvtTYPE_EXPR (ArrayType ls421) = PrettyRep.Ctor ("ArrayType", SOME (PrettyRep.List (List.map (fn x420 => + cvtTYPE_EXPR x420 + ) ls421))) + | cvtTYPE_EXPR (TypeName x427) = PrettyRep.Ctor ("TypeName", SOME (cvtIDENT_EXPR x427)) + | cvtTYPE_EXPR (ElementTypeRef(x430, n431)) = PrettyRep.Ctor ("ElementTypeRef", + SOME (PrettyRep.Tuple [cvtTYPE_EXPR x430, PrettyRep.Int n431])) + | cvtTYPE_EXPR (FieldTypeRef(x435, x436)) = PrettyRep.Ctor ("FieldTypeRef", + SOME (PrettyRep.Tuple [cvtTYPE_EXPR x435, cvtIDENT x436])) + | cvtTYPE_EXPR (FunctionType x440) = PrettyRep.Ctor ("FunctionType", SOME (cvtFUNC_TYPE x440)) + | cvtTYPE_EXPR (ObjectType ls444) = PrettyRep.Ctor ("ObjectType", SOME (PrettyRep.List (List.map (fn x443 => + cvtFIELD_TYPE x443 + ) ls444))) + | cvtTYPE_EXPR (LikeType x450) = PrettyRep.Ctor ("LikeType", SOME (cvtTYPE_EXPR x450)) + | cvtTYPE_EXPR (AppType{base=x453, args=ls455}) = PrettyRep.Ctor ("AppType", + SOME (PrettyRep.Rec [("base", cvtTYPE_EXPR x453), ("args", PrettyRep.List (List.map (fn x454 => + cvtTYPE_EXPR x454 + ) ls455))])) + | cvtTYPE_EXPR (LamType{params=ls467, body=x471}) = PrettyRep.Ctor ("LamType", + SOME (PrettyRep.Rec [("params", PrettyRep.List (List.map (fn x466 => + cvtIDENT x466 + ) ls467)), + ("body", cvtTYPE_EXPR x471)])) + | cvtTYPE_EXPR (NullableType{expr=x479, nullable=b480}) = PrettyRep.Ctor ("NullableType", + SOME (PrettyRep.Rec [("expr", cvtTYPE_EXPR x479), ("nullable", PrettyRep.Bool b480)])) + | cvtTYPE_EXPR (InstanceType x488) = PrettyRep.Ctor ("InstanceType", SOME (cvtINSTANCE_TYPE x488)) and cvtSTMT (EmptyStmt) = PrettyRep.Ctor ("EmptyStmt", NONE) - | cvtSTMT (ExprStmt x495) = PrettyRep.Ctor ("ExprStmt", SOME (cvtEXPR x495)) - | cvtSTMT (InitStmt{kind=x498, ns=opt500, prototype=b504, static=b505, - temps=x506, inits=ls508}) = PrettyRep.Ctor ("InitStmt", SOME (PrettyRep.Rec [("kind", - cvtVAR_DEFN_TAG x498), ("ns", - (case opt500 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x499 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x499)) - )), ("prototype", PrettyRep.Bool b504), ("static", PrettyRep.Bool b505), - ("temps", cvtBINDINGS x506), ("inits", PrettyRep.List (List.map (fn x507 => - cvtINIT_STEP x507 - ) ls508))])) - | cvtSTMT (ClassBlock x527) = PrettyRep.Ctor ("ClassBlock", SOME (cvtCLASS_BLOCK x527)) - | cvtSTMT (ForInStmt x530) = PrettyRep.Ctor ("ForInStmt", SOME (cvtFOR_ENUM_STMT x530)) - | cvtSTMT (ThrowStmt x533) = PrettyRep.Ctor ("ThrowStmt", SOME (cvtEXPR x533)) - | cvtSTMT (ReturnStmt x536) = PrettyRep.Ctor ("ReturnStmt", SOME (cvtEXPR x536)) - | cvtSTMT (BreakStmt opt540) = PrettyRep.Ctor ("BreakStmt", SOME - (case opt540 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x539 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x539)) + | cvtSTMT (ExprStmt x492) = PrettyRep.Ctor ("ExprStmt", SOME (cvtEXPR x492)) + | cvtSTMT (InitStmt{kind=x495, ns=opt497, prototype=b501, static=b502, + temps=x503, inits=ls505}) = PrettyRep.Ctor ("InitStmt", SOME (PrettyRep.Rec [("kind", + cvtVAR_DEFN_TAG x495), ("ns", + (case opt497 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x496 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x496)) + )), ("prototype", PrettyRep.Bool b501), ("static", PrettyRep.Bool b502), + ("temps", cvtBINDINGS x503), ("inits", PrettyRep.List (List.map (fn x504 => + cvtINIT_STEP x504 + ) ls505))])) + | cvtSTMT (ClassBlock x524) = PrettyRep.Ctor ("ClassBlock", SOME (cvtCLASS_BLOCK x524)) + | cvtSTMT (ForInStmt x527) = PrettyRep.Ctor ("ForInStmt", SOME (cvtFOR_ENUM_STMT x527)) + | cvtSTMT (ThrowStmt x530) = PrettyRep.Ctor ("ThrowStmt", SOME (cvtEXPR x530)) + | cvtSTMT (ReturnStmt x533) = PrettyRep.Ctor ("ReturnStmt", SOME (cvtEXPR x533)) + | cvtSTMT (BreakStmt opt537) = PrettyRep.Ctor ("BreakStmt", SOME + (case opt537 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x536 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x536)) )) - | cvtSTMT (ContinueStmt opt547) = PrettyRep.Ctor ("ContinueStmt", SOME - (case opt547 of + | cvtSTMT (ContinueStmt opt544) = PrettyRep.Ctor ("ContinueStmt", SOME + (case opt544 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x546 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x546)) + | SOME x543 => PrettyRep.Ctor ("SOME", SOME (cvtIDENT x543)) )) - | cvtSTMT (BlockStmt x553) = PrettyRep.Ctor ("BlockStmt", SOME (cvtBLOCK x553)) - | cvtSTMT (LabeledStmt(x556, x557)) = PrettyRep.Ctor ("LabeledStmt", SOME (PrettyRep.Tuple [cvtIDENT x556, - cvtSTMT x557])) - | cvtSTMT (LetStmt x561) = PrettyRep.Ctor ("LetStmt", SOME (cvtBLOCK x561)) - | cvtSTMT (WhileStmt x564) = PrettyRep.Ctor ("WhileStmt", SOME (cvtWHILE_STMT x564)) - | cvtSTMT (DoWhileStmt x567) = PrettyRep.Ctor ("DoWhileStmt", SOME (cvtWHILE_STMT x567)) - | cvtSTMT (ForStmt x570) = PrettyRep.Ctor ("ForStmt", SOME (cvtFOR_STMT x570)) - | cvtSTMT (IfStmt{cnd=x573, thn=x574, els=x575}) = PrettyRep.Ctor ("IfStmt", - SOME (PrettyRep.Rec [("cnd", cvtEXPR x573), ("thn", cvtSTMT x574), - ("els", cvtSTMT x575)])) - | cvtSTMT (WithStmt{obj=x585, ty=x586, body=x587}) = PrettyRep.Ctor ("WithStmt", - SOME (PrettyRep.Rec [("obj", cvtEXPR x585), ("ty", cvtTY x586), ("body", - cvtSTMT x587)])) - | cvtSTMT (TryStmt{block=x597, catches=ls599, finally=opt604}) = PrettyRep.Ctor ("TryStmt", - SOME (PrettyRep.Rec [("block", cvtBLOCK x597), ("catches", PrettyRep.List (List.map (fn x598 => - cvtCATCH_CLAUSE x598 - ) ls599)), + | cvtSTMT (BlockStmt x550) = PrettyRep.Ctor ("BlockStmt", SOME (cvtBLOCK x550)) + | cvtSTMT (LabeledStmt(x553, x554)) = PrettyRep.Ctor ("LabeledStmt", SOME (PrettyRep.Tuple [cvtIDENT x553, + cvtSTMT x554])) + | cvtSTMT (LetStmt x558) = PrettyRep.Ctor ("LetStmt", SOME (cvtBLOCK x558)) + | cvtSTMT (WhileStmt x561) = PrettyRep.Ctor ("WhileStmt", SOME (cvtWHILE_STMT x561)) + | cvtSTMT (DoWhileStmt x564) = PrettyRep.Ctor ("DoWhileStmt", SOME (cvtWHILE_STMT x564)) + | cvtSTMT (ForStmt x567) = PrettyRep.Ctor ("ForStmt", SOME (cvtFOR_STMT x567)) + | cvtSTMT (IfStmt{cnd=x570, thn=x571, els=x572}) = PrettyRep.Ctor ("IfStmt", + SOME (PrettyRep.Rec [("cnd", cvtEXPR x570), ("thn", cvtSTMT x571), + ("els", cvtSTMT x572)])) + | cvtSTMT (WithStmt{obj=x582, ty=x583, body=x584}) = PrettyRep.Ctor ("WithStmt", + SOME (PrettyRep.Rec [("obj", cvtEXPR x582), ("ty", cvtTY x583), ("body", + cvtSTMT x584)])) + | cvtSTMT (TryStmt{block=x594, catches=ls596, finally=opt601}) = PrettyRep.Ctor ("TryStmt", + SOME (PrettyRep.Rec [("block", cvtBLOCK x594), ("catches", PrettyRep.List (List.map (fn x595 => + cvtCATCH_CLAUSE x595 + ) ls596)), ("finally", - (case opt604 of + (case opt601 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x603 => PrettyRep.Ctor ("SOME", SOME (cvtBLOCK x603)) + | SOME x600 => PrettyRep.Ctor ("SOME", SOME (cvtBLOCK x600)) ))])) - | cvtSTMT (SwitchStmt{cond=x617, labels=ls619, cases=ls624}) = PrettyRep.Ctor ("SwitchStmt", - SOME (PrettyRep.Rec [("cond", cvtEXPR x617), ("labels", PrettyRep.List (List.map (fn x618 => - cvtIDENT x618 - ) ls619)), - ("cases", PrettyRep.List (List.map (fn x623 => cvtCASE x623 - ) ls624))])) - | cvtSTMT (SwitchTypeStmt{cond=x637, ty=x638, cases=ls640}) = PrettyRep.Ctor ("SwitchTypeStmt", - SOME (PrettyRep.Rec [("cond", cvtEXPR x637), ("ty", cvtTY x638), - ("cases", PrettyRep.List (List.map (fn x639 => cvtCATCH_CLAUSE x639 - ) ls640))])) - | cvtSTMT (DXNStmt{expr=x653}) = PrettyRep.Ctor ("DXNStmt", SOME (PrettyRep.Rec [("expr", - cvtEXPR x653)])) - and cvtEXPR (TernaryExpr(x659, x660, x661)) = PrettyRep.Ctor ("TernaryExpr", - SOME (PrettyRep.Tuple [cvtEXPR x659, cvtEXPR x660, cvtEXPR x661])) - | cvtEXPR (BinaryExpr(x665, x666, x667)) = PrettyRep.Ctor ("BinaryExpr", - SOME (PrettyRep.Tuple [cvtBINOP x665, cvtEXPR x666, cvtEXPR x667])) - | cvtEXPR (BinaryTypeExpr(x671, x672, x673)) = PrettyRep.Ctor ("BinaryTypeExpr", - SOME (PrettyRep.Tuple [cvtBINTYPEOP x671, cvtEXPR x672, cvtTY x673])) - | cvtEXPR (UnaryExpr(x677, x678)) = PrettyRep.Ctor ("UnaryExpr", SOME (PrettyRep.Tuple [cvtUNOP x677, - cvtEXPR x678])) - | cvtEXPR (TypeExpr x682) = PrettyRep.Ctor ("TypeExpr", SOME (cvtTY x682)) - | cvtEXPR (ThisExpr opt686) = PrettyRep.Ctor ("ThisExpr", SOME - (case opt686 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x685 => PrettyRep.Ctor ("SOME", SOME (cvtTHIS_KIND x685)) + | cvtSTMT (SwitchStmt{cond=x614, labels=ls616, cases=ls621}) = PrettyRep.Ctor ("SwitchStmt", + SOME (PrettyRep.Rec [("cond", cvtEXPR x614), ("labels", PrettyRep.List (List.map (fn x615 => + cvtIDENT x615 + ) ls616)), + ("cases", PrettyRep.List (List.map (fn x620 => cvtCASE x620 + ) ls621))])) + | cvtSTMT (SwitchTypeStmt{cond=x634, ty=x635, cases=ls637}) = PrettyRep.Ctor ("SwitchTypeStmt", + SOME (PrettyRep.Rec [("cond", cvtEXPR x634), ("ty", cvtTY x635), + ("cases", PrettyRep.List (List.map (fn x636 => cvtCATCH_CLAUSE x636 + ) ls637))])) + | cvtSTMT (DXNStmt{expr=x650}) = PrettyRep.Ctor ("DXNStmt", SOME (PrettyRep.Rec [("expr", + cvtEXPR x650)])) + and cvtEXPR (TernaryExpr(x656, x657, x658)) = PrettyRep.Ctor ("TernaryExpr", + SOME (PrettyRep.Tuple [cvtEXPR x656, cvtEXPR x657, cvtEXPR x658])) + | cvtEXPR (BinaryExpr(x662, x663, x664)) = PrettyRep.Ctor ("BinaryExpr", + SOME (PrettyRep.Tuple [cvtBINOP x662, cvtEXPR x663, cvtEXPR x664])) + | cvtEXPR (BinaryTypeExpr(x668, x669, x670)) = PrettyRep.Ctor ("BinaryTypeExpr", + SOME (PrettyRep.Tuple [cvtBINTYPEOP x668, cvtEXPR x669, cvtTY x670])) + | cvtEXPR (UnaryExpr(x674, x675)) = PrettyRep.Ctor ("UnaryExpr", SOME (PrettyRep.Tuple [cvtUNOP x674, + cvtEXPR x675])) + | cvtEXPR (TypeExpr x679) = PrettyRep.Ctor ("TypeExpr", SOME (cvtTY x679)) + | cvtEXPR (ThisExpr opt683) = PrettyRep.Ctor ("ThisExpr", SOME + (case opt683 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x682 => PrettyRep.Ctor ("SOME", SOME (cvtTHIS_KIND x682)) )) - | cvtEXPR (YieldExpr opt693) = PrettyRep.Ctor ("YieldExpr", SOME - (case opt693 of + | cvtEXPR (YieldExpr opt690) = PrettyRep.Ctor ("YieldExpr", SOME + (case opt690 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x692 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x692)) + | SOME x689 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x689)) )) - | cvtEXPR (SuperExpr opt700) = PrettyRep.Ctor ("SuperExpr", SOME - (case opt700 of + | cvtEXPR (SuperExpr opt697) = PrettyRep.Ctor ("SuperExpr", SOME + (case opt697 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x699 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x699)) + | SOME x696 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x696)) )) - | cvtEXPR (LiteralExpr x706) = PrettyRep.Ctor ("LiteralExpr", SOME (cvtLITERAL x706)) - | cvtEXPR (CallExpr{func=x709, actuals=ls711}) = PrettyRep.Ctor ("CallExpr", - SOME (PrettyRep.Rec [("func", cvtEXPR x709), ("actuals", PrettyRep.List (List.map (fn x710 => - cvtEXPR x710 - ) ls711))])) - | cvtEXPR (ApplyTypeExpr{expr=x722, actuals=ls724}) = PrettyRep.Ctor ("ApplyTypeExpr", - SOME (PrettyRep.Rec [("expr", cvtEXPR x722), ("actuals", PrettyRep.List (List.map (fn x723 => - cvtTY x723 - ) ls724))])) - | cvtEXPR (LetExpr{defs=x735, body=x736, head=opt738}) = PrettyRep.Ctor ("LetExpr", - SOME (PrettyRep.Rec [("defs", cvtBINDINGS x735), ("body", cvtEXPR x736), + | cvtEXPR (LiteralExpr x703) = PrettyRep.Ctor ("LiteralExpr", SOME (cvtLITERAL x703)) + | cvtEXPR (CallExpr{func=x706, actuals=ls708}) = PrettyRep.Ctor ("CallExpr", + SOME (PrettyRep.Rec [("func", cvtEXPR x706), ("actuals", PrettyRep.List (List.map (fn x707 => + cvtEXPR x707 + ) ls708))])) + | cvtEXPR (ApplyTypeExpr{expr=x719, actuals=ls721}) = PrettyRep.Ctor ("ApplyTypeExpr", + SOME (PrettyRep.Rec [("expr", cvtEXPR x719), ("actuals", PrettyRep.List (List.map (fn x720 => + cvtTY x720 + ) ls721))])) + | cvtEXPR (LetExpr{defs=x732, body=x733, head=opt735}) = PrettyRep.Ctor ("LetExpr", + SOME (PrettyRep.Rec [("defs", cvtBINDINGS x732), ("body", cvtEXPR x733), ("head", - (case opt738 of + (case opt735 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x737 => PrettyRep.Ctor ("SOME", SOME (cvtHEAD x737)) + | SOME x734 => PrettyRep.Ctor ("SOME", SOME (cvtHEAD x734)) ))])) - | cvtEXPR (NewExpr{obj=x751, actuals=ls753}) = PrettyRep.Ctor ("NewExpr", - SOME (PrettyRep.Rec [("obj", cvtEXPR x751), ("actuals", PrettyRep.List (List.map (fn x752 => - cvtEXPR x752 - ) ls753))])) - | cvtEXPR (ObjectRef{base=x764, ident=x765, loc=opt767}) = PrettyRep.Ctor ("ObjectRef", - SOME (PrettyRep.Rec [("base", cvtEXPR x764), ("ident", cvtIDENT_EXPR x765), + | cvtEXPR (NewExpr{obj=x748, actuals=ls750}) = PrettyRep.Ctor ("NewExpr", + SOME (PrettyRep.Rec [("obj", cvtEXPR x748), ("actuals", PrettyRep.List (List.map (fn x749 => + cvtEXPR x749 + ) ls750))])) + | cvtEXPR (ObjectRef{base=x761, ident=x762, loc=opt764}) = PrettyRep.Ctor ("ObjectRef", + SOME (PrettyRep.Rec [("base", cvtEXPR x761), ("ident", cvtIDENT_EXPR x762), ("loc", - (case opt767 of + (case opt764 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x766 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x766)) + | SOME x763 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x763)) ))])) - | cvtEXPR (LexicalRef{ident=x780, loc=opt782}) = PrettyRep.Ctor ("LexicalRef", - SOME (PrettyRep.Rec [("ident", cvtIDENT_EXPR x780), ("loc", - (case opt782 of + | cvtEXPR (LexicalRef{ident=x777, loc=opt779}) = PrettyRep.Ctor ("LexicalRef", + SOME (PrettyRep.Rec [("ident", cvtIDENT_EXPR x777), ("loc", + (case opt779 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x781 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x781)) + | SOME x778 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x778)) ))])) - | cvtEXPR (SetExpr(x793, x794, x795)) = PrettyRep.Ctor ("SetExpr", SOME (PrettyRep.Tuple [cvtASSIGNOP x793, - cvtEXPR x794, cvtEXPR x795])) - | cvtEXPR (ListExpr ls800) = PrettyRep.Ctor ("ListExpr", SOME (PrettyRep.List (List.map (fn x799 => - cvtEXPR x799 - ) ls800))) - | cvtEXPR (InitExpr(x806, x807, x808)) = PrettyRep.Ctor ("InitExpr", SOME (PrettyRep.Tuple [cvtINIT_TARGET x806, - cvtHEAD x807, cvtINITS x808])) - | cvtEXPR (GetTemp n812) = PrettyRep.Ctor ("GetTemp", SOME (PrettyRep.Int n812)) - | cvtEXPR (GetParam n815) = PrettyRep.Ctor ("GetParam", SOME (PrettyRep.Int n815)) - | cvtEXPR (Comprehension(x818, ls820, opt825)) = PrettyRep.Ctor ("Comprehension", - SOME (PrettyRep.Tuple [cvtEXPR x818, PrettyRep.List (List.map (fn x819 => - cvtFOR_ENUM_HEAD x819 - ) ls820), + | cvtEXPR (SetExpr(x790, x791, x792)) = PrettyRep.Ctor ("SetExpr", SOME (PrettyRep.Tuple [cvtASSIGNOP x790, + cvtEXPR x791, cvtEXPR x792])) + | cvtEXPR (ListExpr ls797) = PrettyRep.Ctor ("ListExpr", SOME (PrettyRep.List (List.map (fn x796 => + cvtEXPR x796 + ) ls797))) + | cvtEXPR (InitExpr(x803, x804, x805)) = PrettyRep.Ctor ("InitExpr", SOME (PrettyRep.Tuple [cvtINIT_TARGET x803, + cvtHEAD x804, cvtINITS x805])) + | cvtEXPR (GetTemp n809) = PrettyRep.Ctor ("GetTemp", SOME (PrettyRep.Int n809)) + | cvtEXPR (GetParam n812) = PrettyRep.Ctor ("GetParam", SOME (PrettyRep.Int n812)) + | cvtEXPR (Comprehension(x815, ls817, opt822)) = PrettyRep.Ctor ("Comprehension", + SOME (PrettyRep.Tuple [cvtEXPR x815, PrettyRep.List (List.map (fn x816 => + cvtFOR_ENUM_HEAD x816 + ) ls817), - (case opt825 of + (case opt822 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x824 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x824)) + | SOME x821 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x821)) )])) and cvtINIT_TARGET (Hoisted) = PrettyRep.Ctor ("Hoisted", NONE) | cvtINIT_TARGET (Local) = PrettyRep.Ctor ("Local", NONE) | cvtINIT_TARGET (Prototype) = PrettyRep.Ctor ("Prototype", NONE) and cvtTHIS_KIND (FunctionThis) = PrettyRep.Ctor ("FunctionThis", NONE) | cvtTHIS_KIND (GeneratorThis) = PrettyRep.Ctor ("GeneratorThis", NONE) - and cvtFIXTURE_NAME (TempName n837) = PrettyRep.Ctor ("TempName", SOME (PrettyRep.Int n837)) - | cvtFIXTURE_NAME (PropName x840) = PrettyRep.Ctor ("PropName", SOME (cvtNAME x840)) - and cvtIDENT_EXPR (Identifier{ident=x843, openNamespaces=ls849}) = PrettyRep.Ctor ("Identifier", - SOME (PrettyRep.Rec [("ident", cvtIDENT x843), ("openNamespaces", - PrettyRep.List (List.map (fn ls845 => PrettyRep.List (List.map (fn x844 => - cvtNAMESPACE x844 - ) ls845) - ) ls849))])) - | cvtIDENT_EXPR (QualifiedExpression{qual=x860, expr=x861}) = PrettyRep.Ctor ("QualifiedExpression", - SOME (PrettyRep.Rec [("qual", cvtEXPR x860), ("expr", cvtEXPR x861)])) - | cvtIDENT_EXPR (AttributeIdentifier x869) = PrettyRep.Ctor ("AttributeIdentifier", - SOME (cvtIDENT_EXPR x869)) - | cvtIDENT_EXPR (ExpressionIdentifier{expr=x872, openNamespaces=ls878}) = + and cvtFIXTURE_NAME (TempName n834) = PrettyRep.Ctor ("TempName", SOME (PrettyRep.Int n834)) + | cvtFIXTURE_NAME (PropName x837) = PrettyRep.Ctor ("PropName", SOME (cvtNAME x837)) + and cvtIDENT_EXPR (Identifier{ident=x840, openNamespaces=ls846}) = PrettyRep.Ctor ("Identifier", + SOME (PrettyRep.Rec [("ident", cvtIDENT x840), ("openNamespaces", + PrettyRep.List (List.map (fn ls842 => PrettyRep.List (List.map (fn x841 => + cvtNAMESPACE x841 + ) ls842) + ) ls846))])) + | cvtIDENT_EXPR (QualifiedExpression{qual=x857, expr=x858}) = PrettyRep.Ctor ("QualifiedExpression", + SOME (PrettyRep.Rec [("qual", cvtEXPR x857), ("expr", cvtEXPR x858)])) + | cvtIDENT_EXPR (AttributeIdentifier x866) = PrettyRep.Ctor ("AttributeIdentifier", + SOME (cvtIDENT_EXPR x866)) + | cvtIDENT_EXPR (ExpressionIdentifier{expr=x869, openNamespaces=ls875}) = PrettyRep.Ctor ("ExpressionIdentifier", SOME (PrettyRep.Rec [("expr", - cvtEXPR x872), ("openNamespaces", PrettyRep.List (List.map (fn ls874 => - PrettyRep.List (List.map (fn x873 => - cvtNAMESPACE x873 - ) ls874) - ) ls878))])) - | cvtIDENT_EXPR (QualifiedIdentifier{qual=x889, ident=s890}) = PrettyRep.Ctor ("QualifiedIdentifier", - SOME (PrettyRep.Rec [("qual", cvtEXPR x889), ("ident", PrettyRep.UniStr s890)])) - | cvtIDENT_EXPR (UnresolvedPath(ls899, x903)) = PrettyRep.Ctor ("UnresolvedPath", - SOME (PrettyRep.Tuple [PrettyRep.List (List.map (fn x898 => cvtIDENT x898 - ) ls899), cvtIDENT_EXPR x903])) + cvtEXPR x869), ("openNamespaces", PrettyRep.List (List.map (fn ls871 => + PrettyRep.List (List.map (fn x870 => + cvtNAMESPACE x870 + ) ls871) + ) ls875))])) + | cvtIDENT_EXPR (QualifiedIdentifier{qual=x886, ident=s887}) = PrettyRep.Ctor ("QualifiedIdentifier", + SOME (PrettyRep.Rec [("qual", cvtEXPR x886), ("ident", PrettyRep.UniStr s887)])) + | cvtIDENT_EXPR (UnresolvedPath(ls896, x900)) = PrettyRep.Ctor ("UnresolvedPath", + SOME (PrettyRep.Tuple [PrettyRep.List (List.map (fn x895 => cvtIDENT x895 + ) ls896), cvtIDENT_EXPR x900])) | cvtIDENT_EXPR (WildcardIdentifier) = PrettyRep.Ctor ("WildcardIdentifier", NONE) and cvtLITERAL (LiteralNull) = PrettyRep.Ctor ("LiteralNull", NONE) | cvtLITERAL (LiteralUndefined) = PrettyRep.Ctor ("LiteralUndefined", NONE) - | cvtLITERAL (LiteralDouble r910) = PrettyRep.Ctor ("LiteralDouble", SOME (PrettyRep.Real64 r910)) - | cvtLITERAL (LiteralDecimal d913) = PrettyRep.Ctor ("LiteralDecimal", - SOME (PrettyRep.Dec d913)) - | cvtLITERAL (LiteralBoolean b916) = PrettyRep.Ctor ("LiteralBoolean", - SOME (PrettyRep.Bool b916)) - | cvtLITERAL (LiteralString s919) = PrettyRep.Ctor ("LiteralString", SOME (PrettyRep.UniStr s919)) - | cvtLITERAL (LiteralArray{exprs=x922, ty=opt924}) = PrettyRep.Ctor ("LiteralArray", - SOME (PrettyRep.Rec [("exprs", cvtEXPR x922), ("ty", - (case opt924 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x923 => PrettyRep.Ctor ("SOME", SOME (cvtTY x923)) + | cvtLITERAL (LiteralDouble r907) = PrettyRep.Ctor ("LiteralDouble", SOME (PrettyRep.Real64 r907)) + | cvtLITERAL (LiteralDecimal d910) = PrettyRep.Ctor ("LiteralDecimal", + SOME (PrettyRep.Dec d910)) + | cvtLITERAL (LiteralBoolean b913) = PrettyRep.Ctor ("LiteralBoolean", + SOME (PrettyRep.Bool b913)) + | cvtLITERAL (LiteralString s916) = PrettyRep.Ctor ("LiteralString", SOME (PrettyRep.UniStr s916)) + | cvtLITERAL (LiteralArray{exprs=x919, ty=opt921}) = PrettyRep.Ctor ("LiteralArray", + SOME (PrettyRep.Rec [("exprs", cvtEXPR x919), ("ty", + (case opt921 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x920 => PrettyRep.Ctor ("SOME", SOME (cvtTY x920)) ))])) - | cvtLITERAL (LiteralXML ls936) = PrettyRep.Ctor ("LiteralXML", SOME (PrettyRep.List (List.map (fn x935 => - cvtEXPR x935 - ) ls936))) - | cvtLITERAL (LiteralNamespace x942) = PrettyRep.Ctor ("LiteralNamespace", - SOME (cvtNAMESPACE x942)) - | cvtLITERAL (LiteralObject{expr=ls946, ty=opt951}) = PrettyRep.Ctor ("LiteralObject", - SOME (PrettyRep.Rec [("expr", PrettyRep.List (List.map (fn x945 => - cvtFIELD x945 - ) ls946)), + | cvtLITERAL (LiteralXML ls933) = PrettyRep.Ctor ("LiteralXML", SOME (PrettyRep.List (List.map (fn x932 => + cvtEXPR x932 + ) ls933))) + | cvtLITERAL (LiteralNamespace x939) = PrettyRep.Ctor ("LiteralNamespace", + SOME (cvtNAMESPACE x939)) + | cvtLITERAL (LiteralObject{expr=ls943, ty=opt948}) = PrettyRep.Ctor ("LiteralObject", + SOME (PrettyRep.Rec [("expr", PrettyRep.List (List.map (fn x942 => + cvtFIELD x942 + ) ls943)), ("ty", - (case opt951 of + (case opt948 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x950 => PrettyRep.Ctor ("SOME", SOME (cvtTY x950)) + | SOME x947 => PrettyRep.Ctor ("SOME", SOME (cvtTY x947)) ))])) - | cvtLITERAL (LiteralFunction x962) = PrettyRep.Ctor ("LiteralFunction", - SOME (cvtFUNC x962)) - | cvtLITERAL (LiteralRegExp{str=s965}) = PrettyRep.Ctor ("LiteralRegExp", - SOME (PrettyRep.Rec [("str", PrettyRep.UniStr s965)])) - and cvtBLOCK (Block x971) = PrettyRep.Ctor ("Block", SOME (cvtDIRECTIVES x971)) - and cvtFIXTURE (NamespaceFixture x974) = PrettyRep.Ctor ("NamespaceFixture", - SOME (cvtNAMESPACE x974)) - | cvtFIXTURE (ClassFixture x977) = PrettyRep.Ctor ("ClassFixture", SOME (cvtCLS x977)) - | cvtFIXTURE (InterfaceFixture x980) = PrettyRep.Ctor ("InterfaceFixture", - SOME (cvtIFACE x980)) - | cvtFIXTURE (TypeVarFixture x983) = PrettyRep.Ctor ("TypeVarFixture", - SOME (cvtTYPEVAR_NONCE x983)) - | cvtFIXTURE (TypeFixture x986) = PrettyRep.Ctor ("TypeFixture", SOME (cvtTY x986)) - | cvtFIXTURE (MethodFixture{func=x989, ty=x990, readOnly=b991, override=b992, - final=b993}) = PrettyRep.Ctor ("MethodFixture", SOME (PrettyRep.Rec [("func", - cvtFUNC x989), ("ty", cvtTY x990), ("readOnly", PrettyRep.Bool b991), - ("override", PrettyRep.Bool b992), ("final", PrettyRep.Bool b993)])) - | cvtFIXTURE (ValFixture{ty=x1007, readOnly=b1008}) = PrettyRep.Ctor ("ValFixture", - SOME (PrettyRep.Rec [("ty", cvtTY x1007), ("readOnly", PrettyRep.Bool b1008)])) - | cvtFIXTURE (VirtualValFixture{ty=x1016, getter=opt1018, setter=opt1023}) = + | cvtLITERAL (LiteralFunction x959) = PrettyRep.Ctor ("LiteralFunction", + SOME (cvtFUNC x959)) + | cvtLITERAL (LiteralRegExp{str=s962}) = PrettyRep.Ctor ("LiteralRegExp", + SOME (PrettyRep.Rec [("str", PrettyRep.UniStr s962)])) + and cvtBLOCK (Block x968) = PrettyRep.Ctor ("Block", SOME (cvtDIRECTIVES x968)) + and cvtFIXTURE (NamespaceFixture x971) = PrettyRep.Ctor ("NamespaceFixture", + SOME (cvtNAMESPACE x971)) + | cvtFIXTURE (ClassFixture x974) = PrettyRep.Ctor ("ClassFixture", SOME (cvtCLS x974)) + | cvtFIXTURE (InterfaceFixture x977) = PrettyRep.Ctor ("InterfaceFixture", + SOME (cvtIFACE x977)) + | cvtFIXTURE (TypeVarFixture x980) = PrettyRep.Ctor ("TypeVarFixture", + SOME (cvtTYPEVAR_NONCE x980)) + | cvtFIXTURE (TypeFixture x983) = PrettyRep.Ctor ("TypeFixture", SOME (cvtTY x983)) + | cvtFIXTURE (MethodFixture{func=x986, ty=x987, readOnly=b988, override=b989, + final=b990}) = PrettyRep.Ctor ("MethodFixture", SOME (PrettyRep.Rec [("func", + cvtFUNC x986), ("ty", cvtTY x987), ("readOnly", PrettyRep.Bool b988), + ("override", PrettyRep.Bool b989), ("final", PrettyRep.Bool b990)])) + | cvtFIXTURE (ValFixture{ty=x1004, readOnly=b1005}) = PrettyRep.Ctor ("ValFixture", + SOME (PrettyRep.Rec [("ty", cvtTY x1004), ("readOnly", PrettyRep.Bool b1005)])) + | cvtFIXTURE (VirtualValFixture{ty=x1013, getter=opt1015, setter=opt1020}) = PrettyRep.Ctor ("VirtualValFixture", SOME (PrettyRep.Rec [("ty", - cvtTY x1016), ("getter", - (case opt1018 of + cvtTY x1013), ("getter", + (case opt1015 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1017 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1017)) + | SOME x1014 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1014)) )), ("setter", - (case opt1023 of + (case opt1020 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1022 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1022)) + | SOME x1019 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1019)) ))])) - | cvtFIXTURE (InheritedFixture{baseName=x1036, baseTypeArgs=ls1038}) = + | cvtFIXTURE (InheritedFixture{baseName=x1033, baseTypeArgs=ls1035}) = PrettyRep.Ctor ("InheritedFixture", SOME (PrettyRep.Rec [("baseName", - cvtNAME x1036), ("baseTypeArgs", PrettyRep.List (List.map (fn x1037 => - cvtTY x1037 - ) ls1038))])) - and cvtHEAD (Head(x1049, x1050)) = PrettyRep.Ctor ("Head", SOME (PrettyRep.Tuple [cvtRIB x1049, - cvtINITS x1050])) - and cvtBINDINGS (ls1055, ls1060) = PrettyRep.Tuple [PrettyRep.List (List.map (fn x1054 => - cvtBINDING x1054 - ) ls1055), - PrettyRep.List (List.map (fn x1059 => cvtINIT_STEP x1059 - ) ls1060)] - and cvtRIB ls1068 = PrettyRep.List (List.map (fn (x1065, x1066) => PrettyRep.Tuple [cvtFIXTURE_NAME x1065, - cvtFIXTURE x1066] - ) ls1068) - and cvtRIBS ls1079 = PrettyRep.List (List.map (fn ls1075 => PrettyRep.List (List.map (fn (x1072, - x1073) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1072, - cvtFIXTURE x1073] - ) ls1075) - ) ls1079) - and cvtINITS ls1086 = PrettyRep.List (List.map (fn (x1083, x1084) => PrettyRep.Tuple [cvtFIXTURE_NAME x1083, - cvtEXPR x1084] - ) ls1086) - and cvtINSTANCE_TYPE {name=x1090, typeParams=ls1092, typeArgs=ls1097, nonnullable=b1101, - superTypes=ls1103, ty=x1107, dynamic=b1108} = PrettyRep.Rec [("name", - cvtNAME x1090), ("typeParams", PrettyRep.List (List.map (fn x1091 => - cvtIDENT x1091 - ) ls1092)), - ("typeArgs", PrettyRep.List (List.map (fn x1096 => cvtTYPE_EXPR x1096 - ) ls1097)), ("nonnullable", - PrettyRep.Bool b1101), ("superTypes", PrettyRep.List (List.map (fn x1102 => - cvtTYPE_EXPR x1102 - ) ls1103)), - ("ty", cvtTYPE_EXPR x1107), ("dynamic", PrettyRep.Bool b1108)] - and cvtFIELD {kind=x1124, name=x1125, init=x1126} = PrettyRep.Rec [("kind", - cvtVAR_DEFN_TAG x1124), ("name", cvtIDENT_EXPR x1125), ("init", cvtEXPR x1126)] - and cvtFIELD_TYPE {name=x1134, ty=x1135} = PrettyRep.Rec [("name", cvtIDENT x1134), - ("ty", cvtTYPE_EXPR x1135)] - and cvtFUNC_TYPE {params=ls1142, result=x1146, thisType=opt1148, hasRest=b1152, - minArgs=n1153} = PrettyRep.Rec [("params", PrettyRep.List (List.map (fn x1141 => - cvtTYPE_EXPR x1141 - ) ls1142)), - ("result", cvtTYPE_EXPR x1146), ("thisType", - (case opt1148 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1147 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x1147)) - )), ("hasRest", PrettyRep.Bool b1152), ("minArgs", PrettyRep.Int n1153)] - and cvtFUNC_DEFN {kind=x1165, ns=opt1167, final=b1171, override=b1172, prototype=b1173, - static=b1174, func=x1175} = PrettyRep.Rec [("kind", cvtVAR_DEFN_TAG x1165), + cvtNAME x1033), ("baseTypeArgs", PrettyRep.List (List.map (fn x1034 => + cvtTY x1034 + ) ls1035))])) + and cvtHEAD (Head(x1046, x1047)) = PrettyRep.Ctor ("Head", SOME (PrettyRep.Tuple [cvtRIB x1046, + cvtINITS x1047])) + and cvtBINDINGS (ls1052, ls1057) = PrettyRep.Tuple [PrettyRep.List (List.map (fn x1051 => + cvtBINDING x1051 + ) ls1052), + PrettyRep.List (List.map (fn x1056 => cvtINIT_STEP x1056 + ) ls1057)] + and cvtRIB ls1065 = PrettyRep.List (List.map (fn (x1062, x1063) => PrettyRep.Tuple [cvtFIXTURE_NAME x1062, + cvtFIXTURE x1063] + ) ls1065) + and cvtRIBS ls1076 = PrettyRep.List (List.map (fn ls1072 => PrettyRep.List (List.map (fn (x1069, + x1070) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1069, + cvtFIXTURE x1070] + ) ls1072) + ) ls1076) + and cvtINITS ls1083 = PrettyRep.List (List.map (fn (x1080, x1081) => PrettyRep.Tuple [cvtFIXTURE_NAME x1080, + cvtEXPR x1081] + ) ls1083) + and cvtINSTANCE_TYPE {name=x1087, typeParams=ls1089, typeArgs=ls1094, nonnullable=b1098, + superTypes=ls1100, ty=x1104, dynamic=b1105} = PrettyRep.Rec [("name", + cvtNAME x1087), ("typeParams", PrettyRep.List (List.map (fn x1088 => + cvtIDENT x1088 + ) ls1089)), + ("typeArgs", PrettyRep.List (List.map (fn x1093 => cvtTYPE_EXPR x1093 + ) ls1094)), ("nonnullable", + PrettyRep.Bool b1098), ("superTypes", PrettyRep.List (List.map (fn x1099 => + cvtTYPE_EXPR x1099 + ) ls1100)), + ("ty", cvtTYPE_EXPR x1104), ("dynamic", PrettyRep.Bool b1105)] + and cvtFIELD {kind=x1121, name=x1122, init=x1123} = PrettyRep.Rec [("kind", + cvtVAR_DEFN_TAG x1121), ("name", cvtIDENT_EXPR x1122), ("init", cvtEXPR x1123)] + and cvtFIELD_TYPE {name=x1131, ty=x1132} = PrettyRep.Rec [("name", cvtIDENT x1131), + ("ty", cvtTYPE_EXPR x1132)] + and cvtFUNC_TYPE {params=ls1139, result=x1143, thisType=opt1145, hasRest=b1149, + minArgs=n1150} = PrettyRep.Rec [("params", PrettyRep.List (List.map (fn x1138 => + cvtTYPE_EXPR x1138 + ) ls1139)), + ("result", cvtTYPE_EXPR x1143), ("thisType", + (case opt1145 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1144 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x1144)) + )), ("hasRest", PrettyRep.Bool b1149), ("minArgs", PrettyRep.Int n1150)] + and cvtFUNC_DEFN {kind=x1162, ns=opt1164, final=b1168, override=b1169, prototype=b1170, + static=b1171, func=x1172} = PrettyRep.Rec [("kind", cvtVAR_DEFN_TAG x1162), ("ns", - (case opt1167 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1166 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1166)) - )), ("final", PrettyRep.Bool b1171), ("override", PrettyRep.Bool b1172), - ("prototype", PrettyRep.Bool b1173), ("static", PrettyRep.Bool b1174), - ("func", cvtFUNC x1175)] - and cvtCTOR_DEFN x1191 = cvtCTOR x1191 - and cvtVAR_DEFN {kind=x1192, ns=opt1194, static=b1198, prototype=b1199, - bindings=(ls1201, ls1206)} = PrettyRep.Rec [("kind", cvtVAR_DEFN_TAG x1192), + (case opt1164 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1163 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1163)) + )), ("final", PrettyRep.Bool b1168), ("override", PrettyRep.Bool b1169), + ("prototype", PrettyRep.Bool b1170), ("static", PrettyRep.Bool b1171), + ("func", cvtFUNC x1172)] + and cvtCTOR_DEFN x1188 = cvtCTOR x1188 + and cvtVAR_DEFN {kind=x1189, ns=opt1191, static=b1195, prototype=b1196, + bindings=(ls1198, ls1203)} = PrettyRep.Rec [("kind", cvtVAR_DEFN_TAG x1189), ("ns", - (case opt1194 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1193 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1193)) - )), ("static", PrettyRep.Bool b1198), ("prototype", PrettyRep.Bool b1199), - ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1200 => - cvtBINDING x1200 - ) ls1201), - PrettyRep.List (List.map (fn x1205 => cvtINIT_STEP x1205 - ) ls1206)])] - and cvtNAMESPACE_DEFN {ident=x1222, ns=opt1224, init=opt1229} = PrettyRep.Rec [("ident", - cvtIDENT x1222), ("ns", - (case opt1224 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1223 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1223)) + (case opt1191 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1190 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1190)) + )), ("static", PrettyRep.Bool b1195), ("prototype", PrettyRep.Bool b1196), + ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1197 => + cvtBINDING x1197 + ) ls1198), + PrettyRep.List (List.map (fn x1202 => cvtINIT_STEP x1202 + ) ls1203)])] + and cvtNAMESPACE_DEFN {ident=x1219, ns=opt1221, init=opt1226} = PrettyRep.Rec [("ident", + cvtIDENT x1219), ("ns", + (case opt1221 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1220 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1220)) )), ("init", - (case opt1229 of + (case opt1226 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1228 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1228)) + | SOME x1225 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1225)) ))] - and cvtCLASS_DEFN {ns=opt1241, ident=x1245, nonnullable=b1246, dynamic=b1247, - final=b1248, params=ls1250, extends=opt1255, implements=ls1260, classDefns=ls1265, - instanceDefns=ls1270, instanceStmts=ls1275, ctorDefn=opt1280} = PrettyRep.Rec [("ns", + and cvtCLASS_DEFN {ns=opt1238, ident=x1242, nonnullable=b1243, dynamic=b1244, + final=b1245, params=ls1247, extends=opt1252, implements=ls1257, classDefns=ls1262, + instanceDefns=ls1267, instanceStmts=ls1272, ctorDefn=opt1277} = PrettyRep.Rec [("ns", - (case opt1241 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1240 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1240)) - )), ("ident", cvtIDENT x1245), ("nonnullable", PrettyRep.Bool b1246), - ("dynamic", PrettyRep.Bool b1247), ("final", PrettyRep.Bool b1248), - ("params", PrettyRep.List (List.map (fn x1249 => cvtIDENT x1249 - ) ls1250)), ("extends", - (case opt1255 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1254 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x1254)) - )), ("implements", PrettyRep.List (List.map (fn x1259 => cvtTYPE_EXPR x1259 - ) ls1260)), ("classDefns", - PrettyRep.List (List.map (fn x1264 => cvtDEFN x1264 - ) ls1265)), ("instanceDefns", PrettyRep.List (List.map (fn x1269 => - cvtDEFN x1269 - ) ls1270)), - ("instanceStmts", PrettyRep.List (List.map (fn x1274 => cvtSTMT x1274 - ) ls1275)), ("ctorDefn", + (case opt1238 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1237 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1237)) + )), ("ident", cvtIDENT x1242), ("nonnullable", PrettyRep.Bool b1243), + ("dynamic", PrettyRep.Bool b1244), ("final", PrettyRep.Bool b1245), + ("params", PrettyRep.List (List.map (fn x1246 => cvtIDENT x1246 + ) ls1247)), ("extends", + (case opt1252 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1251 => PrettyRep.Ctor ("SOME", SOME (cvtTYPE_EXPR x1251)) + )), ("implements", PrettyRep.List (List.map (fn x1256 => cvtTYPE_EXPR x1256 + ) ls1257)), ("classDefns", + PrettyRep.List (List.map (fn x1261 => cvtDEFN x1261 + ) ls1262)), ("instanceDefns", PrettyRep.List (List.map (fn x1266 => + cvtDEFN x1266 + ) ls1267)), + ("instanceStmts", PrettyRep.List (List.map (fn x1271 => cvtSTMT x1271 + ) ls1272)), ("ctorDefn", - (case opt1280 of + (case opt1277 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1279 => PrettyRep.Ctor ("SOME", SOME (cvtCTOR x1279)) + | SOME x1276 => PrettyRep.Ctor ("SOME", SOME (cvtCTOR x1276)) ))] - and cvtINTERFACE_DEFN {ident=x1309, ns=opt1311, nonnullable=b1315, params=ls1317, - extends=ls1322, instanceDefns=ls1327} = PrettyRep.Rec [("ident", - cvtIDENT x1309), ("ns", - (case opt1311 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1310 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1310)) - )), ("nonnullable", PrettyRep.Bool b1315), ("params", PrettyRep.List (List.map (fn x1316 => - cvtIDENT x1316 - ) ls1317)), - ("extends", PrettyRep.List (List.map (fn x1321 => cvtTYPE_EXPR x1321 - ) ls1322)), ("instanceDefns", - PrettyRep.List (List.map (fn x1326 => cvtDEFN x1326 - ) ls1327))] - and cvtTYPE_DEFN {ident=x1344, ns=opt1346, init=x1350} = PrettyRep.Rec [("ident", - cvtIDENT x1344), ("ns", - (case opt1346 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1345 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1345)) - )), ("init", cvtTYPE_EXPR x1350)] - and cvtCLASS_BLOCK {ns=opt1359, ident=x1363, name=opt1365, block=x1369} = + and cvtINTERFACE_DEFN {ident=x1306, ns=opt1308, nonnullable=b1312, params=ls1314, + extends=ls1319, instanceDefns=ls1324} = PrettyRep.Rec [("ident", + cvtIDENT x1306), ("ns", + (case opt1308 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1307 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1307)) + )), ("nonnullable", PrettyRep.Bool b1312), ("params", PrettyRep.List (List.map (fn x1313 => + cvtIDENT x1313 + ) ls1314)), + ("extends", PrettyRep.List (List.map (fn x1318 => cvtTYPE_EXPR x1318 + ) ls1319)), ("instanceDefns", + PrettyRep.List (List.map (fn x1323 => cvtDEFN x1323 + ) ls1324))] + and cvtTYPE_DEFN {ident=x1341, ns=opt1343, init=x1347} = PrettyRep.Rec [("ident", + cvtIDENT x1341), ("ns", + (case opt1343 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1342 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1342)) + )), ("init", cvtTYPE_EXPR x1347)] + and cvtCLASS_BLOCK {ns=opt1356, ident=x1360, name=opt1362, block=x1366} = PrettyRep.Rec [("ns", - (case opt1359 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1358 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1358)) - )), ("ident", cvtIDENT x1363), ("name", - (case opt1365 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1364 => PrettyRep.Ctor ("SOME", SOME (cvtNAME x1364)) - )), ("block", cvtBLOCK x1369)] - and cvtFOR_ENUM_HEAD {isEach=b1379, bindings=(ls1381, ls1386), expr=x1391} = - PrettyRep.Rec [("isEach", PrettyRep.Bool b1379), ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1380 => - cvtBINDING x1380 - ) ls1381), - PrettyRep.List (List.map (fn x1385 => cvtINIT_STEP x1385 - ) ls1386)]), ("expr", cvtEXPR x1391)] - and cvtFOR_ENUM_STMT {isEach=b1399, defn=opt1430, obj=x1434, rib=opt1442, - next=x1446, labels=ls1448, body=x1452} = PrettyRep.Rec [("isEach", - PrettyRep.Bool b1399), ("defn", - (case opt1430 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME{kind=x1400, ns=opt1402, static=b1406, prototype=b1407, bindings=(ls1409, - ls1414)} => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Rec [("kind", - cvtVAR_DEFN_TAG x1400), ("ns", - (case opt1402 of + (case opt1356 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1355 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1355)) + )), ("ident", cvtIDENT x1360), ("name", + (case opt1362 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1361 => PrettyRep.Ctor ("SOME", SOME (cvtNAME x1361)) + )), ("block", cvtBLOCK x1366)] + and cvtFOR_ENUM_HEAD {isEach=b1376, bindings=(ls1378, ls1383), expr=x1388} = + PrettyRep.Rec [("isEach", PrettyRep.Bool b1376), ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1377 => + cvtBINDING x1377 + ) ls1378), + PrettyRep.List (List.map (fn x1382 => cvtINIT_STEP x1382 + ) ls1383)]), ("expr", cvtEXPR x1388)] + and cvtFOR_ENUM_STMT {isEach=b1396, defn=opt1427, obj=x1431, rib=opt1439, + next=x1443, labels=ls1445, body=x1449} = PrettyRep.Rec [("isEach", + PrettyRep.Bool b1396), ("defn", + (case opt1427 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME{kind=x1397, ns=opt1399, static=b1403, prototype=b1404, bindings=(ls1406, + ls1411)} => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Rec [("kind", + cvtVAR_DEFN_TAG x1397), ("ns", + (case opt1399 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1401 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1401)) - )), ("static", PrettyRep.Bool b1406), ("prototype", PrettyRep.Bool b1407), - ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1408 => - cvtBINDING x1408 - ) ls1409), - PrettyRep.List (List.map (fn x1413 => cvtINIT_STEP x1413 - ) ls1414)])])) - )), ("obj", cvtEXPR x1434), ("rib", - (case opt1442 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME ls1438 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1435, - x1436) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1435, - cvtFIXTURE x1436] - ) ls1438))) - )), ("next", cvtSTMT x1446), ("labels", PrettyRep.List (List.map (fn x1447 => - cvtIDENT x1447 - ) ls1448)), - ("body", cvtSTMT x1452)] - and cvtFOR_STMT {rib=opt1475, defn=opt1509, init=ls1514, cond=x1518, update=x1519, - labels=ls1521, body=x1525} = PrettyRep.Rec [("rib", - (case opt1475 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME ls1471 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1468, - x1469) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1468, - cvtFIXTURE x1469] - ) ls1471))) + | SOME x1398 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1398)) + )), ("static", PrettyRep.Bool b1403), ("prototype", PrettyRep.Bool b1404), + ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1405 => + cvtBINDING x1405 + ) ls1406), + PrettyRep.List (List.map (fn x1410 => cvtINIT_STEP x1410 + ) ls1411)])])) + )), ("obj", cvtEXPR x1431), ("rib", + (case opt1439 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME ls1435 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1432, + x1433) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1432, + cvtFIXTURE x1433] + ) ls1435))) + )), ("next", cvtSTMT x1443), ("labels", PrettyRep.List (List.map (fn x1444 => + cvtIDENT x1444 + ) ls1445)), + ("body", cvtSTMT x1449)] + and cvtFOR_STMT {rib=opt1472, defn=opt1506, init=ls1511, cond=x1515, update=x1516, + labels=ls1518, body=x1522} = PrettyRep.Rec [("rib", + (case opt1472 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME ls1468 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1465, + x1466) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1465, + cvtFIXTURE x1466] + ) ls1468))) )), ("defn", - (case opt1509 of + (case opt1506 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME{kind=x1479, ns=opt1481, static=b1485, prototype=b1486, bindings=(ls1488, - ls1493)} => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Rec [("kind", - cvtVAR_DEFN_TAG x1479), ("ns", - (case opt1481 of + | SOME{kind=x1476, ns=opt1478, static=b1482, prototype=b1483, bindings=(ls1485, + ls1490)} => PrettyRep.Ctor ("SOME", SOME (PrettyRep.Rec [("kind", + cvtVAR_DEFN_TAG x1476), ("ns", + (case opt1478 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1480 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1480)) - )), ("static", PrettyRep.Bool b1485), ("prototype", PrettyRep.Bool b1486), - ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1487 => - cvtBINDING x1487 - ) ls1488), - PrettyRep.List (List.map (fn x1492 => cvtINIT_STEP x1492 - ) ls1493)])])) - )), ("init", PrettyRep.List (List.map (fn x1513 => cvtSTMT x1513 - ) ls1514)), ("cond", cvtEXPR x1518), - ("update", cvtEXPR x1519), ("labels", PrettyRep.List (List.map (fn x1520 => - cvtIDENT x1520 - ) ls1521)), - ("body", cvtSTMT x1525)] - and cvtWHILE_STMT {cond=x1541, rib=opt1549, body=x1553, labels=ls1555} = - PrettyRep.Rec [("cond", cvtEXPR x1541), ("rib", - (case opt1549 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME ls1545 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1542, - x1543) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1542, - cvtFIXTURE x1543] - ) ls1545))) - )), ("body", cvtSTMT x1553), ("labels", PrettyRep.List (List.map (fn x1554 => - cvtIDENT x1554 - ) ls1555))] - and cvtDIRECTIVES {pragmas=ls1569, defns=ls1574, head=opt1579, body=ls1584, - loc=opt1589} = PrettyRep.Rec [("pragmas", PrettyRep.List (List.map (fn x1568 => - cvtPRAGMA x1568 - ) ls1569)), - ("defns", PrettyRep.List (List.map (fn x1573 => cvtDEFN x1573 - ) ls1574)), ("head", - (case opt1579 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1578 => PrettyRep.Ctor ("SOME", SOME (cvtHEAD x1578)) - )), ("body", PrettyRep.List (List.map (fn x1583 => cvtSTMT x1583 - ) ls1584)), ("loc", - (case opt1589 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1588 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x1588)) + | SOME x1477 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1477)) + )), ("static", PrettyRep.Bool b1482), ("prototype", PrettyRep.Bool b1483), + ("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1484 => + cvtBINDING x1484 + ) ls1485), + PrettyRep.List (List.map (fn x1489 => cvtINIT_STEP x1489 + ) ls1490)])])) + )), ("init", PrettyRep.List (List.map (fn x1510 => cvtSTMT x1510 + ) ls1511)), ("cond", cvtEXPR x1515), + ("update", cvtEXPR x1516), ("labels", PrettyRep.List (List.map (fn x1517 => + cvtIDENT x1517 + ) ls1518)), + ("body", cvtSTMT x1522)] + and cvtWHILE_STMT {cond=x1538, rib=opt1546, body=x1550, labels=ls1552} = + PrettyRep.Rec [("cond", cvtEXPR x1538), ("rib", + (case opt1546 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME ls1542 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1539, + x1540) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1539, + cvtFIXTURE x1540] + ) ls1542))) + )), ("body", cvtSTMT x1550), ("labels", PrettyRep.List (List.map (fn x1551 => + cvtIDENT x1551 + ) ls1552))] + and cvtDIRECTIVES {pragmas=ls1566, defns=ls1571, head=opt1576, body=ls1581, + loc=opt1586} = PrettyRep.Rec [("pragmas", PrettyRep.List (List.map (fn x1565 => + cvtPRAGMA x1565 + ) ls1566)), + ("defns", PrettyRep.List (List.map (fn x1570 => cvtDEFN x1570 + ) ls1571)), ("head", + (case opt1576 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1575 => PrettyRep.Ctor ("SOME", SOME (cvtHEAD x1575)) + )), ("body", PrettyRep.List (List.map (fn x1580 => cvtSTMT x1580 + ) ls1581)), ("loc", + (case opt1586 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1585 => PrettyRep.Ctor ("SOME", SOME (cvtLOC x1585)) ))] - and cvtCASE {label=opt1605, inits=opt1616, body=x1620} = PrettyRep.Rec [("label", + and cvtCASE {label=opt1602, inits=opt1613, body=x1617} = PrettyRep.Rec [("label", - (case opt1605 of + (case opt1602 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1604 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1604)) + | SOME x1601 => PrettyRep.Ctor ("SOME", SOME (cvtEXPR x1601)) )), ("inits", - (case opt1616 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME ls1612 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1609, - x1610) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1609, - cvtEXPR x1610] - ) ls1612))) - )), ("body", cvtBLOCK x1620)] - and cvtCATCH_CLAUSE {bindings=(ls1629, ls1634), ty=x1639, rib=opt1647, inits=opt1658, - block=x1662} = PrettyRep.Rec [("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1628 => - cvtBINDING x1628 - ) ls1629), - PrettyRep.List (List.map (fn x1633 => cvtINIT_STEP x1633 - ) ls1634)]), ("ty", cvtTY x1639), ("rib", + (case opt1613 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME ls1609 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1606, + x1607) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1606, + cvtEXPR x1607] + ) ls1609))) + )), ("body", cvtBLOCK x1617)] + and cvtCATCH_CLAUSE {bindings=(ls1626, ls1631), ty=x1636, rib=opt1644, inits=opt1655, + block=x1659} = PrettyRep.Rec [("bindings", PrettyRep.Tuple [PrettyRep.List (List.map (fn x1625 => + cvtBINDING x1625 + ) ls1626), + PrettyRep.List (List.map (fn x1630 => cvtINIT_STEP x1630 + ) ls1631)]), ("ty", cvtTY x1636), ("rib", - (case opt1647 of + (case opt1644 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME ls1643 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1640, - x1641) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1640, - cvtFIXTURE x1641] - ) ls1643))) + | SOME ls1640 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1637, + x1638) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1637, + cvtFIXTURE x1638] + ) ls1640))) )), ("inits", - (case opt1658 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME ls1654 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1651, - x1652) => - PrettyRep.Tuple [cvtFIXTURE_NAME x1651, - cvtEXPR x1652] - ) ls1654))) - )), ("block", cvtBLOCK x1662)] - and cvtFUNC_NAME {kind=x1674, ident=x1675} = PrettyRep.Rec [("kind", cvtFUNC_NAME_KIND x1674), - ("ident", cvtIDENT x1675)] - and cvtVIRTUAL_VAL_FIXTURE {ty=x1681, getter=opt1683, setter=opt1688} = - PrettyRep.Rec [("ty", cvtTY x1681), ("getter", - (case opt1683 of - NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1682 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1682)) + (case opt1655 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME ls1651 => PrettyRep.Ctor ("SOME", SOME (PrettyRep.List (List.map (fn (x1648, + x1649) => + PrettyRep.Tuple [cvtFIXTURE_NAME x1648, + cvtEXPR x1649] + ) ls1651))) + )), ("block", cvtBLOCK x1659)] + and cvtFUNC_NAME {kind=x1671, ident=x1672} = PrettyRep.Rec [("kind", cvtFUNC_NAME_KIND x1671), + ("ident", cvtIDENT x1672)] + and cvtVIRTUAL_VAL_FIXTURE {ty=x1678, getter=opt1680, setter=opt1685} = + PrettyRep.Rec [("ty", cvtTY x1678), ("getter", + (case opt1680 of + NONE => PrettyRep.Ctor ("NONE", NONE) + | SOME x1679 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1679)) )), ("setter", - (case opt1688 of + (case opt1685 of NONE => PrettyRep.Ctor ("NONE", NONE) - | SOME x1687 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1687)) + | SOME x1684 => PrettyRep.Ctor ("SOME", SOME (cvtFUNC x1684)) ))] - and cvtFRAGMENT (Package{name=ls1700, fragments=ls1705}) = PrettyRep.Ctor ("Package", - SOME (PrettyRep.Rec [("name", PrettyRep.List (List.map (fn x1699 => - cvtIDENT x1699 - ) ls1700)), - ("fragments", PrettyRep.List (List.map (fn x1704 => cvtFRAGMENT x1704 - ) ls1705))])) - | cvtFRAGMENT (Anon x1716) = PrettyRep.Ctor ("Anon", SOME (cvtBLOCK x1716)) + and cvtFRAGMENT (Package{name=ls1697, fragments=ls1702}) = PrettyRep.Ctor ("Package", + SOME (PrettyRep.Rec [("name", PrettyRep.List (List.map (fn x1696 => + cvtIDENT x1696 + ) ls1697)), + ("fragments", PrettyRep.List (List.map (fn x1701 => cvtFRAGMENT x1701 + ) ls1702))])) + | cvtFRAGMENT (Anon x1713) = PrettyRep.Ctor ("Anon", SOME (cvtBLOCK x1713)) end