From 36c265d98de7ac4ed15b6145dafff0b771dfa2d5 Mon Sep 17 00:00:00 2001 From: Shadaj Laddad Date: Fri, 18 Aug 2023 13:58:28 -0400 Subject: [PATCH] Support subset types in the Rust backend (#4422) Support subset types in the Rust backend By submitting this pull request, I confirm that my contribution is made under the terms of the [MIT license](https://github.com/dafny-lang/dafny/blob/master/LICENSE.txt). --- Stack created with [Sapling](https://sapling-scm.com). Best reviewed with [ReviewStack](https://reviewstack.dev/dafny-lang/dafny/pull/4422). * #4438 * #4429 * __->__ #4422 --- .github/workflows/msbuild.yml | 2 +- Makefile | 2 +- Source/DafnyCore/Compilers/Dafny/AST.dfy | 7 +- .../DafnyCore/Compilers/Dafny/ASTBuilder.cs | 122 +- .../Compilers/Dafny/Compiler-dafny.cs | 92 +- .../Compilers/Rust/Dafny-compiler-rust.dfy | 414 +- Source/DafnyCore/GeneratedFromDafnyRust.cs | 3402 +++++++++-------- .../DafnyRuntime/DafnyRuntimeRust/Cargo.lock | 7 + .../DafnyRuntime/DafnyRuntimeRust/Cargo.toml | 1 + .../DafnyRuntime/DafnyRuntimeRust/src/lib.rs | 225 +- docs/DafnyRef/Features.md | 20 +- 11 files changed, 2627 insertions(+), 1667 deletions(-) diff --git a/.github/workflows/msbuild.yml b/.github/workflows/msbuild.yml index f149fca7e6f..61805e91a58 100644 --- a/.github/workflows/msbuild.yml +++ b/.github/workflows/msbuild.yml @@ -55,7 +55,7 @@ jobs: run: dotnet build Source/Dafny.sln - name: Check whitespace and style working-directory: dafny - run: dotnet tool run dotnet-format -w -s error --check Source/Dafny.sln --exclude DafnyCore/Scanner.cs --exclude DafnyCore/Parser.cs + run: dotnet tool run dotnet-format -w -s error --check Source/Dafny.sln --exclude DafnyCore/Scanner.cs --exclude DafnyCore/Parser.cs --exclude DafnyCore/GeneratedFromDafny.cs --exclude DafnyCore/GeneratedFromDafnyRust.cs - name: Create NuGet package (just to make sure it works) run: dotnet pack --no-build dafny/Source/Dafny.sln - name: Check uniformity of integration tests that exercise backends diff --git a/Makefile b/Makefile index 9d7355ffe0e..fbd17ba228c 100644 --- a/Makefile +++ b/Makefile @@ -58,7 +58,7 @@ z3-ubuntu: chmod +x ${DIR}/Binaries/z3/bin/z3-* format: - dotnet tool run dotnet-format -w -s error Source/Dafny.sln --exclude DafnyCore/Scanner.cs --exclude DafnyCore/Parser.cs + dotnet tool run dotnet-format -w -s error Source/Dafny.sln --exclude DafnyCore/Scanner.cs --exclude DafnyCore/Parser.cs --exclude DafnyCore/GeneratedFromDafny.cs --exclude DafnyCore/GeneratedFromDafnyRust.cs clean: (cd ${DIR}; cd Source; rm -rf Dafny/bin Dafny/obj DafnyDriver/bin DafnyDriver/obj DafnyRuntime/obj DafnyRuntime/bin DafnyServer/bin DafnyServer/obj DafnyPipeline/obj DafnyPipeline/bin DafnyCore/obj DafnyCore/bin) diff --git a/Source/DafnyCore/Compilers/Dafny/AST.dfy b/Source/DafnyCore/Compilers/Dafny/AST.dfy index 28b0ceea77d..fed8be7fd59 100644 --- a/Source/DafnyCore/Compilers/Dafny/AST.dfy +++ b/Source/DafnyCore/Compilers/Dafny/AST.dfy @@ -3,7 +3,7 @@ module {:extern "DAST"} DAST { datatype ModuleItem = Module(Module) | Class(Class) | Trait(Trait) | Newtype(Newtype) | Datatype(Datatype) - datatype Newtype = Newtype(name: string, base: Type, witnessExpr: Optional) + datatype Newtype = Newtype(name: string, typeParams: seq, base: Type, witnessStmts: seq, witnessExpr: Optional) datatype Type = Path(seq, typeArgs: seq, resolved: ResolvedType) | @@ -58,7 +58,8 @@ module {:extern "DAST"} DAST { New(path: seq, args: seq) | NewArray(dims: seq) | DatatypeValue(path: seq, variant: string, isCo: bool, contents: seq<(string, Expression)>) | - NewtypeValue(tpe: Type, value: Expression) | + SubsetUpgrade(value: Expression, typ: Type) | + SubsetDowngrade(value: Expression) | SeqValue(elements: seq) | SetValue(elements: seq) | This() | @@ -69,7 +70,7 @@ module {:extern "DAST"} DAST { SelectFn(expr: Expression, field: string, onDatatype: bool, isStatic: bool, arity: nat) | TupleSelect(expr: Expression, index: nat) | Call(on: Expression, name: Ident, typeArgs: seq, args: seq) | - Lambda(params: seq, body: seq) | + Lambda(params: seq, retType: Type, body: seq) | IIFE(name: Ident, typ: Type, value: Expression, iifeBody: Expression) | Apply(expr: Expression, args: seq) | TypeTest(on: Expression, dType: seq, variant: string) | diff --git a/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs b/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs index dc3389e97a2..a644181607b 100644 --- a/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs +++ b/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs @@ -149,21 +149,25 @@ public object Finish() { interface NewtypeContainer { void AddNewtype(Newtype item); - public NewtypeBuilder Newtype(string name, DAST.Type baseType, DAST.Expression witness) { - return new NewtypeBuilder(this, name, baseType, witness); + public NewtypeBuilder Newtype(string name, List typeParams, DAST.Type baseType, List witnessStmts, DAST.Expression witness) { + return new NewtypeBuilder(this, name, typeParams, baseType, witnessStmts, witness); } } class NewtypeBuilder : ClassLike { readonly NewtypeContainer parent; readonly string name; + readonly List typeParams; readonly DAST.Type baseType; + readonly List witnessStmts; readonly DAST.Expression witness; - public NewtypeBuilder(NewtypeContainer parent, string name, DAST.Type baseType, DAST.Expression witness) { + public NewtypeBuilder(NewtypeContainer parent, string name, List typeParams, DAST.Type baseType, List statements, DAST.Expression witness) { this.parent = parent; this.name = name; + this.typeParams = typeParams; this.baseType = baseType; + this.witnessStmts = statements; this.witness = witness; } @@ -178,7 +182,9 @@ public void AddField(DAST.Formal item) { public object Finish() { parent.AddNewtype((Newtype)Newtype.create( Sequence.UnicodeFromString(this.name), + Sequence.FromArray(this.typeParams.ToArray()), this.baseType, + Sequence.FromArray(this.witnessStmts.ToArray()), this.witness == null ? Optional.create_None() : Optional.create_Some(this.witness) )); return parent; @@ -699,6 +705,31 @@ public DAST.Statement Build() { } } + class StatementBuffer : StatementContainer { + readonly List statements = new(); + + public void AddStatement(DAST.Statement item) { + statements.Add(item); + } + + public void AddBuildable(BuildableStatement item) { + statements.Add(item); + } + + public List ForkList() { + var ret = new List(); + statements.Add(ret); + return ret; + } + + public List PopAll() { + var builtResult = new List(); + StatementContainer.RecursivelyBuild(statements, builtResult); + + return builtResult; + } + } + class ExprBuffer : ExprContainer { Stack exprs = new(); public readonly object parent; @@ -761,8 +792,8 @@ CallExprBuilder Call() { return ret; } - LambdaExprBuilder Lambda(List formals) { - var ret = new LambdaExprBuilder(formals); + LambdaExprBuilder Lambda(List formals, DAST.Type retType) { + var ret = new LambdaExprBuilder(formals, retType); AddBuildable(ret); return ret; } @@ -773,6 +804,18 @@ IIFEExprBuilder IIFE(string name, DAST.Type tpe) { return ret; } + SubsetUpgradeBuilder SubsetUpgrade(DAST.Type tpe) { + var ret = new SubsetUpgradeBuilder(tpe); + AddBuildable(ret); + return ret; + } + + SubsetDowngradeBuilder SubsetDowngrade() { + var ret = new SubsetDowngradeBuilder(); + AddBuildable(ret); + return ret; + } + protected static void RecursivelyBuild(List body, List builtExprs) { foreach (var maybeBuilt in body) { if (maybeBuilt is DAST.Expression built) { @@ -886,10 +929,12 @@ public DAST.Expression Build() { class LambdaExprBuilder : StatementContainer, BuildableExpr { readonly List formals; + readonly DAST.Type retType; readonly List body = new(); - public LambdaExprBuilder(List formals) { + public LambdaExprBuilder(List formals, DAST.Type retType) { this.formals = formals; + this.retType = retType; } public void AddStatement(DAST.Statement item) { @@ -912,6 +957,7 @@ public DAST.Expression Build() { return (DAST.Expression)DAST.Expression.create_Lambda( Sequence.FromArray(formals.ToArray()), + retType, Sequence.FromArray(builtBody.ToArray()) ); } @@ -988,3 +1034,67 @@ public void AddBuildable(BuildableExpr item) { } } } + +class SubsetUpgradeBuilder : ExprContainer, BuildableExpr { + readonly DAST.Type tpe; + object value = null; + + public SubsetUpgradeBuilder(DAST.Type tpe) { + this.tpe = tpe; + } + + public void AddExpr(DAST.Expression item) { + if (value != null) { + throw new InvalidOperationException(); + } else { + value = item; + } + } + + public void AddBuildable(BuildableExpr item) { + if (value != null) { + throw new InvalidOperationException(); + } else { + value = item; + } + } + + public DAST.Expression Build() { + var builtValue = new List(); + ExprContainer.RecursivelyBuild(new List { value }, builtValue); + + return (DAST.Expression)DAST.Expression.create_SubsetUpgrade( + builtValue[0], + tpe + ); + } +} + +class SubsetDowngradeBuilder : ExprContainer, BuildableExpr { + object value = null; + + public void AddExpr(DAST.Expression item) { + if (value != null) { + throw new InvalidOperationException(); + } else { + value = item; + } + } + + public void AddBuildable(BuildableExpr item) { + if (value != null) { + throw new InvalidOperationException(); + } else { + value = item; + } + } + + public DAST.Expression Build() { + var builtValue = new List(); + ExprContainer.RecursivelyBuild(new List { value }, builtValue); + + return (DAST.Expression)DAST.Expression.create_SubsetDowngrade( + builtValue[0] + ); + } +} diff --git a/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs b/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs index 0a197915e83..2a7df063b9f 100644 --- a/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs +++ b/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs @@ -58,24 +58,15 @@ public DafnyCompiler(DafnyOptions options, ErrorReporter reporter) : base(option } public override IReadOnlySet UnsupportedFeatures => new HashSet { - Feature.UnboundedIntegers, - Feature.RealNumbers, Feature.Ordinals, - Feature.FunctionValues, Feature.Iterators, - Feature.CollectionsOfTraits, - Feature.AllUnderscoreExternalModuleNames, Feature.Multisets, - Feature.RuntimeTypeDescriptors, - Feature.MultiDimensionalArrays, Feature.MapComprehensions, Feature.LetSuchThatExpressions, - Feature.NonNativeNewtypes, Feature.MethodSynthesis, Feature.ExternalClasses, Feature.NewObject, Feature.NonSequentializableForallStatements, - Feature.ArrayLength, Feature.MapItems, Feature.RunAllTests, Feature.IntBoundedPool, @@ -91,7 +82,6 @@ public DafnyCompiler(DafnyOptions options, ErrorReporter reporter) : base(option Feature.SequenceUpdateExpressions, Feature.SequenceConstructionsWithNonLambdaInitializers, Feature.ExternalConstructors, - Feature.TupleInitialization, Feature.SubtypeConstraintsInQuantifiers, Feature.TuplesWiderThan20, }; @@ -139,6 +129,24 @@ private static string MangleName(string name) { return name; } + protected override ConcreteSyntaxTree EmitCoercionIfNecessary(Type from, Type to, IToken tok, ConcreteSyntaxTree wr) { + if (from.AsSubsetType == null && to.AsSubsetType != null) { + if (wr is BuilderSyntaxTree stmt) { + return new BuilderSyntaxTree(stmt.Builder.SubsetUpgrade(GenType(to))); + } else { + return base.EmitCoercionIfNecessary(from, to, tok, wr); + } + } else if (from.AsSubsetType != null && to.AsSubsetType == null) { + if (wr is BuilderSyntaxTree stmt) { + return new BuilderSyntaxTree(stmt.Builder.SubsetDowngrade()); + } else { + return base.EmitCoercionIfNecessary(from, to, tok, wr); + } + } else { + return base.EmitCoercionIfNecessary(from, to, tok, wr); + } + } + protected override IClassWriter CreateClass(string moduleName, string name, bool isExtern, string fullPrintName, List typeParameters, TopLevelDecl cls, List superClasses, IToken tok, ConcreteSyntaxTree wr) { if (currentBuilder is ClassContainer builder) { @@ -198,14 +206,17 @@ dt is CoDatatypeDecl protected override IClassWriter DeclareNewtype(NewtypeDecl nt, ConcreteSyntaxTree wr) { if (currentBuilder is NewtypeContainer builder) { + List witnessStmts = new(); DAST.Expression witness = null; if (nt.WitnessKind == SubsetTypeDecl.WKind.Compiled) { var buf = new ExprBuffer(null); - EmitExpr(nt.Witness, false, new BuilderSyntaxTree(buf), null); + var statementBuf = new StatementBuffer(); + EmitExpr(nt.Witness, false, new BuilderSyntaxTree(buf), new BuilderSyntaxTree(statementBuf)); witness = buf.Finish(); + witnessStmts = statementBuf.PopAll(); } - return new ClassWriter(this, builder.Newtype(nt.GetCompileName(Options), GenType(nt.BaseType), witness)); + return new ClassWriter(this, builder.Newtype(nt.GetCompileName(Options), new(), GenType(nt.BaseType), witnessStmts, witness)); } else { throw new InvalidOperationException(); } @@ -213,7 +224,7 @@ protected override IClassWriter DeclareNewtype(NewtypeDecl nt, ConcreteSyntaxTre private DAST.Type GenType(Type typ) { // TODO(shadaj): this is leaking Rust types into the AST, but we do need native types - var xType = DatatypeWrapperEraser.SimplifyType(Options, typ); + var xType = DatatypeWrapperEraser.SimplifyType(Options, typ, true); if (xType is BoolType) { return (DAST.Type)DAST.Type.create_Primitive(DAST.Primitive.create_Bool()); @@ -264,8 +275,26 @@ private DAST.Type GenType(Type typ) { } protected override void DeclareSubsetType(SubsetTypeDecl sst, ConcreteSyntaxTree wr) { - // TODO(shadaj): currently ignores subset types because they appear in the prelude - // throw new NotImplementedException(); + if (currentBuilder is NewtypeContainer builder) { + List witnessStmts = new(); + DAST.Expression witness = null; + if (sst.WitnessKind == SubsetTypeDecl.WKind.Compiled) { + var statementBuf = new StatementBuffer(); + var buf = new ExprBuffer(null); + EmitExpr(sst.Witness, false, new BuilderSyntaxTree(buf), new BuilderSyntaxTree(statementBuf)); + witness = buf.Finish(); + witnessStmts = statementBuf.PopAll(); + } + + List typeParams = new(); + foreach (var tp in sst.TypeArgs) { + typeParams.Add((DAST.Type)DAST.Type.create_TypeArg(Sequence.UnicodeFromString(tp.Name))); + } + + builder.Newtype(sst.GetCompileName(Options), typeParams, GenType(sst.Rhs), witnessStmts, witness).Finish(); + } else { + throw new InvalidOperationException(); + } } protected override void GetNativeInfo(NativeType.Selection sel, out string name, out string literalSuffix, out bool needsCastAfterArithmetic) { @@ -421,7 +450,7 @@ protected override ConcreteSyntaxTree EmitReturnExpr(ConcreteSyntaxTree wr) { } protected override string TypeDescriptor(Type type, ConcreteSyntaxTree wr, IToken tok) { - type = DatatypeWrapperEraser.SimplifyType(Options, type, true); + type = DatatypeWrapperEraser.SimplifyType(Options, type); return type.ToString(); } @@ -930,11 +959,8 @@ protected override void EmitLiteralExpr(ConcreteSyntaxTree wr, LiteralExpr e) { break; } - if (e.Type.AsNewtype != null) { - baseExpr = (DAST.Expression)DAST.Expression.create_NewtypeValue( - GenType(e.Type), - baseExpr - ); + if (e.Type.AsNewtype != null || e.Type.AsSubsetType != null) { + baseExpr = (DAST.Expression)DAST.Expression.create_SubsetUpgrade(baseExpr, GenType(e.Type)); } builder.Builder.AddExpr(baseExpr); @@ -981,7 +1007,8 @@ protected override string FullTypeName(UserDefinedType udt, MemberDecl member = } private DAST.Type FullTypeNameAST(UserDefinedType udt, MemberDecl member = null) { - if (udt is ArrowType arrow) { + if (udt.IsArrowType) { + var arrow = udt.AsArrowType; return (DAST.Type)DAST.Type.create_Arrow( Sequence.FromArray(arrow.Args.Select(m => GenType(m)).ToArray()), GenType(arrow.Result) @@ -1013,6 +1040,13 @@ private ISequence> PathFromTopLevel(TopLevelDecl topLevel) { private DAST.Type TypeNameASTFromTopLevel(TopLevelDecl topLevel, List typeArgs) { var path = PathFromTopLevel(topLevel); + // TODO(shadaj): do something with nullable references + // bool nonNull = false; + if (topLevel is NonNullTypeDecl non) { + // nonNull = true; + topLevel = non.Rhs.AsTopLevelTypeWithMembers; + } + ResolvedType resolvedType; if (topLevel is NewtypeDecl) { resolvedType = (DAST.ResolvedType)DAST.ResolvedType.create_Newtype(); @@ -1023,6 +1057,8 @@ private DAST.Type TypeNameASTFromTopLevel(TopLevelDecl topLevel, List type } else if (topLevel is ClassDecl) { // TODO(shadaj): have a separate type when we properly support classes resolvedType = (DAST.ResolvedType)DAST.ResolvedType.create_Datatype(path); + } else if (topLevel is SubsetTypeDecl) { + resolvedType = (DAST.ResolvedType)DAST.ResolvedType.create_Newtype(); } else { throw new InvalidOperationException(topLevel.GetType().ToString()); } @@ -1060,7 +1096,7 @@ public override void EmitExpr(Expression expr, bool inLetExprBody, ConcreteSynta // sometimes, we don't actually call EmitDatatypeValue currentBuilder = origBuilder; } - } else if (expr is BinaryExpr) { + } else if (expr is BinaryExpr bin) { var origBuilder = currentBuilder; base.EmitExpr(expr, inLetExprBody, actualWr, wStmts); currentBuilder = origBuilder; @@ -1299,7 +1335,9 @@ protected override ConcreteSyntaxTree CreateLambda(List inTypes, IToken to )); } - return new BuilderSyntaxTree(builder.Builder.Lambda(formals)); + var retType = GenType(resultType); + + return new BuilderSyntaxTree(builder.Builder.Lambda(formals, retType)); } else { throw new InvalidOperationException(); } @@ -1482,7 +1520,7 @@ protected override void EmitConstructorCheck(string source, DatatypeCtor ctor, C } protected override void EmitTypeTest(string localName, Type fromType, Type toType, IToken tok, ConcreteSyntaxTree wr) { - throw new NotImplementedException(); + throw new UnsupportedFeatureException(tok, Feature.TypeTests); } protected override void EmitCollectionDisplay(CollectionType ct, IToken tok, List elements, @@ -1550,11 +1588,11 @@ protected override Type EmitIntegerRange(Type type, out ConcreteSyntaxTree wLo, protected override void EmitSingleValueGenerator(Expression e, bool inLetExprBody, string type, ConcreteSyntaxTree wr, ConcreteSyntaxTree wStmts) { - throw new NotImplementedException(); + throw new UnsupportedFeatureException(Token.NoToken, Feature.ExactBoundedPool); } protected override void EmitHaltRecoveryStmt(Statement body, string haltMessageVarName, Statement recoveryBody, ConcreteSyntaxTree wr) { - throw new NotImplementedException(); + throw new UnsupportedFeatureException(Token.NoToken, Feature.RunAllTests); } } diff --git a/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy b/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy index 8c425b88539..df615ddf0ca 100644 --- a/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy +++ b/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy @@ -81,7 +81,7 @@ module {:extern "DCOMP"} DCOMP { var tp := t.typeParams[tpI]; typeParamsSet := typeParamsSet + {tp}; var genTp := GenType(tp, false, false); - typeParams := typeParams + "r#" + genTp + ", "; + typeParams := typeParams + genTp + ", "; tpI := tpI + 1; } typeParams := typeParams + ">"; @@ -93,14 +93,59 @@ module {:extern "DCOMP"} DCOMP { } static method GenNewtype(c: Newtype) returns (s: string) { + var typeParamsSet := {}; + var typeParams := ""; + var constrainedTypeParams := ""; + var tpI := 0; + if |c.typeParams| > 0 { + typeParams := "<"; + constrainedTypeParams := "<"; + while tpI < |c.typeParams| { + var tp := c.typeParams[tpI]; + typeParamsSet := typeParamsSet + {tp}; + var genTp := GenType(tp, false, false); + typeParams := typeParams + genTp + ", "; + constrainedTypeParams := constrainedTypeParams + genTp + ": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<" + genTp + "> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static, "; + tpI := tpI + 1; + } + typeParams := typeParams + ">"; + constrainedTypeParams := constrainedTypeParams + ">"; + } + var underlyingType := GenType(c.base, false, false); - s := "#[derive(Clone, PartialEq)]\npub struct r#" + c.name + "(pub " + underlyingType + ");\n"; - s := s + "impl ::std::default::Default for r#" + c.name + " {\n"; + s := "#[derive(Clone, PartialEq)]\n#[repr(transparent)]\npub struct r#" + c.name + typeParams + "(pub " + underlyingType + ");\n"; + s := s + "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyErasable for r#" + c.name + typeParams + " {\n"; + s := s + "type Erased = " + underlyingType + ";\n"; + s := s + "#[inline]\nfn erase(&self) -> &Self::Erased {\n"; + s := s + "&self.0\n"; + s := s + "}\n"; + s := s + "#[inline]\nfn erase_owned(self) -> Self::Erased {\n"; + s := s + "self.0\n"; + s := s + "}\n"; + s := s + "}\n"; + s := s + "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyUnerasable<" + underlyingType + "> for r#" + c.name + typeParams + " {\n"; + s := s + "#[inline]\nfn unerase(x: &" + underlyingType + ") -> &Self {\n"; + s := s + "unsafe { &*(x as *const " + underlyingType + " as *const r#" + c.name + typeParams + ") }\n"; + s := s + "}\n"; + s := s + "#[inline]\nfn unerase_owned(x: " + underlyingType + ") -> Self {\n"; + s := s + "r#" + c.name + "(x)\n"; + s := s + "}\n"; + s := s + "}\n"; + s := s + "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyUnerasable for r#" + c.name + typeParams + " {\n"; + s := s + "#[inline]\nfn unerase(x: &r#" + c.name + typeParams + ") -> &Self {\n"; + s := s + "x\n"; + s := s + "}\n"; + s := s + "#[inline]\nfn unerase_owned(x: r#" + c.name + typeParams + ") -> Self {\n"; + s := s + "x\n"; + s := s + "}\n"; + s := s + "}\n"; + s := s + "impl " + constrainedTypeParams + " ::std::default::Default for r#" + c.name + typeParams + " {\n"; s := s + "fn default() -> Self {\n"; match c.witnessExpr { case Some(e) => { - var eStr, _, _ := GenExpr(e, [], true); + // TODO(shadaj): generate statements + var eStr, _, _, _ := GenExpr(e, [], true); s := s + "r#" + c.name + "(" + eStr + ")\n"; } case None => { @@ -110,32 +155,10 @@ module {:extern "DCOMP"} DCOMP { s := s + "}\n"; s := s + "}\n"; - s := s + "impl ::dafny_runtime::DafnyPrint for r#" + c.name + " {\n"; + s := s + "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyPrint for r#" + c.name + typeParams + " {\n"; s := s + "fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, in_seq: bool) -> ::std::fmt::Result {\n"; s := s + "::dafny_runtime::DafnyPrint::fmt_print(&self.0, __fmt_print_formatter, in_seq)\n"; s := s + "}\n"; - s := s + "}"; - - // inherit common traits - var ops := [("::std::ops::Add", "add"), ("::std::ops::Sub", "sub"), ("::std::ops::Mul", "mul"), ("::std::ops::Div", "div")]; - var i := 0; - while i < |ops| { - var (traitName, methodName) := ops[i]; - s := s + "impl " + traitName + " for r#" + c.name; - s := s + " where " + underlyingType + ": " + traitName + "<" + underlyingType + ", Output = " + underlyingType + "> {\n"; - s := s + "type Output = r#" + c.name + ";\n"; - s := s + "fn " + methodName + "(self, other: r#" + c.name + ") -> r#" + c.name + " {\n"; - s := s + "r#" + c.name + "(" + traitName + "::" + methodName + "(self.0, other.0))\n"; - s := s + "}\n"; - s := s + "}\n"; - i := i + 1; - } - - s := s + "impl ::std::cmp::PartialOrd for r#" + c.name; - s := s + " where " + underlyingType + ": ::std::cmp::PartialOrd<" + underlyingType + "> {\n"; - s := s + "fn partial_cmp(&self, other: &r#" + c.name + ") -> ::std::option::Option<::std::cmp::Ordering> {\n"; - s := s + "self.0.partial_cmp(&other.0)\n"; - s := s + "}\n"; s := s + "}\n"; } @@ -149,7 +172,7 @@ module {:extern "DCOMP"} DCOMP { var tp := c.typeParams[tpI]; typeParamsSet := typeParamsSet + {tp}; var genTp := GenType(tp, false, false); - typeParams := typeParams + "r#" + genTp + ", "; + typeParams := typeParams + genTp + ", "; tpI := tpI + 1; } typeParams := typeParams + ">"; @@ -244,7 +267,7 @@ module {:extern "DCOMP"} DCOMP { var tp := c.typeParams[tpI]; var genTp := GenType(tp, false, false); - constrainedTypeParams := constrainedTypeParams + "r#" + genTp + ": Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static"; + constrainedTypeParams := constrainedTypeParams + genTp + ": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<" + genTp + "> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static"; tpI := tpI + 1; } constrainedTypeParams := constrainedTypeParams + ">"; @@ -252,6 +275,9 @@ module {:extern "DCOMP"} DCOMP { var enumBody := "#[derive(PartialEq)]\npub enum r#" + c.name + typeParams + " {\n" + ctors + "\n}" + "\n" + "impl " + constrainedTypeParams + " r#" + c.name + typeParams + " {\n" + implBody + "\n}"; + var identEraseImpls := "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyErasable for r#" + c.name + typeParams + " {\n" + "type Erased = Self;\nfn erase(&self) -> &Self::Erased { self }\nfn erase_owned(self) -> Self::Erased { self }}\n"; + identEraseImpls := identEraseImpls + "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyUnerasable for r#" + c.name + typeParams + " {\n" + "fn unerase(x: &Self) -> &Self { x }\nfn unerase_owned(x: Self) -> Self { x }}\n"; + var printImpl := "impl " + constrainedTypeParams + " ::dafny_runtime::DafnyPrint for r#" + c.name + typeParams + " {\n" + "fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n" + "match self {\n"; i := 0; while i < |c.ctors| { @@ -301,7 +327,7 @@ module {:extern "DCOMP"} DCOMP { defaultImpl := defaultImpl + "}\n}\n}\n"; } - s := enumBody + "\n" + printImpl + "\n" + defaultImpl; + s := enumBody + "\n" + identEraseImpls + "\n" + printImpl + "\n" + defaultImpl; } static method GenPath(p: seq) returns (s: string) { @@ -405,9 +431,9 @@ module {:extern "DCOMP"} DCOMP { s := "::dafny_runtime::FunctionWrapper<_>"; } else { if inFn { - s := "::dafny_runtime::FunctionWrapper s := name; + case TypeArg(Ident(name)) => s := "r#" + name; case Primitive(p) => { match p { case String => s := "Vec"; @@ -562,7 +588,7 @@ module {:extern "DCOMP"} DCOMP { } var typeString := GenType(typeParamsFiltered[i], false, false); - s := s + typeString + ": Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static"; + s := s + typeString + ": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<" + typeString + "> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static"; i := i + 1; } @@ -593,7 +619,7 @@ module {:extern "DCOMP"} DCOMP { case None => {} } - var body, _ := GenStmts(m.body, paramNames, earlyReturn); + var body, _ := GenStmts(m.body, paramNames, true, earlyReturn); match m.outVars { case Some(outVars) => { body := body + "\n" + earlyReturn; @@ -607,13 +633,13 @@ module {:extern "DCOMP"} DCOMP { } } - static method GenStmts(stmts: seq, params: seq, earlyReturn: string) returns (generated: string, readIdents: set) { + static method GenStmts(stmts: seq, params: seq, isLast: bool, earlyReturn: string) returns (generated: string, readIdents: set) { generated := ""; readIdents := {}; var i := 0; while i < |stmts| { var stmt := stmts[i]; - var stmtString, recIdents := GenStmt(stmt, params, earlyReturn); + var stmtString, recIdents := GenStmt(stmt, params, isLast && (i == |stmts| - 1), earlyReturn); readIdents := readIdents + recIdents; if i > 0 { @@ -625,10 +651,14 @@ module {:extern "DCOMP"} DCOMP { } } - static method GenStmt(stmt: Statement, params: seq, earlyReturn: string) returns (generated: string, readIdents: set) { + static method GenStmt(stmt: Statement, params: seq, isLast: bool, earlyReturn: string) returns (generated: string, readIdents: set) { match stmt { case DeclareVar(name, typ, Some(expression)) => { - var expr, _, recIdents := GenExpr(expression, params, true); + var expr, _, recErased, recIdents := GenExpr(expression, params, true); + if recErased { + expr := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + expr + ")"; + } + var typeString := GenType(typ, true, false); generated := "let mut r#" + name + ": " + typeString + " = " + expr + ";"; readIdents := recIdents; @@ -639,23 +669,35 @@ module {:extern "DCOMP"} DCOMP { readIdents := {}; } case Assign(name, expression) => { - var expr, _, recIdents := GenExpr(expression, params, true); + var expr, _, recErased, recIdents := GenExpr(expression, params, true); + if recErased { + expr := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + expr + ")"; + } + generated := "r#" + name + " = " + expr + ";"; readIdents := recIdents; } case If(cond, thn, els) => { - var condString, _, recIdents := GenExpr(cond, params, true); + var condString, _, condErased, recIdents := GenExpr(cond, params, true); + if !condErased { + condString := "::dafny_runtime::DafnyErasable::erase_owned(" + condString + ")"; + } + readIdents := recIdents; - var thnString, thnIdents := GenStmts(thn, params, earlyReturn); + var thnString, thnIdents := GenStmts(thn, params, isLast, earlyReturn); readIdents := readIdents + thnIdents; - var elsString, elsIdents := GenStmts(els, params, earlyReturn); + var elsString, elsIdents := GenStmts(els, params, isLast, earlyReturn); readIdents := readIdents + elsIdents; generated := "if " + condString + " {\n" + thnString + "\n} else {\n" + elsString + "\n}"; } case While(cond, body) => { - var condString, _, recIdents := GenExpr(cond, params, true); + var condString, _, condErased, recIdents := GenExpr(cond, params, true); + if !condErased { + condString := "::dafny_runtime::DafnyErasable::erase(" + condString + ")"; + } + readIdents := recIdents; - var bodyString, bodyIdents := GenStmts(body, params, earlyReturn); + var bodyString, bodyIdents := GenStmts(body, params, false, earlyReturn); readIdents := readIdents + bodyIdents; generated := "while " + condString + " {\n" + bodyString + "\n}"; } @@ -686,14 +728,18 @@ module {:extern "DCOMP"} DCOMP { argString := argString + ", "; } - var argExpr, isOwned, argIdents := GenExpr(args[i], params, false); - argString := argString + (if isOwned then "&" else "") + argExpr; + var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], params, false); + if isOwned { + argExpr := "&" + argExpr; + } + + argString := argString + argExpr; readIdents := readIdents + argIdents; i := i + 1; } - var enclosingString, _, enclosingIdents := GenExpr(on, params, true); + var enclosingString, _, _, enclosingIdents := GenExpr(on, params, true); readIdents := readIdents + enclosingIdents; match on { case Companion(_) => { @@ -733,9 +779,15 @@ module {:extern "DCOMP"} DCOMP { enclosingString + "r#" + name + typeArgString + "(" + argString + ");"; } case Return(expr) => { - var exprString, _, recIdents := GenExpr(expr, params, true); + var exprString, _, recErased, recIdents := GenExpr(expr, params, true); + exprString := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + exprString + ")"; readIdents := recIdents; - generated := "return " + exprString + ";"; + + if isLast { + generated := exprString; + } else { + generated := "return " + exprString + ";"; + } } case EarlyReturn() => { generated := earlyReturn; @@ -746,23 +798,25 @@ module {:extern "DCOMP"} DCOMP { readIdents := {}; } case Print(e) => { - var printedExpr, isOwned, recIdents := GenExpr(e, params, false); + var printedExpr, isOwned, _, recIdents := GenExpr(e, params, false); generated := "print!(\"{}\", ::dafny_runtime::DafnyPrintWrapper(" + (if isOwned then "&" else "") + printedExpr + "));"; readIdents := recIdents; } } } - static method GenExpr(e: Expression, params: seq, mustOwn: bool) returns (s: string, isOwned: bool, readIdents: set) { + static method GenExpr(e: Expression, params: seq, mustOwn: bool) returns (s: string, isOwned: bool, isErased: bool, readIdents: set) { match e { case Literal(BoolLiteral(false)) => { s := "false"; isOwned := true; + isErased := true; readIdents := {}; } case Literal(BoolLiteral(true)) => { s := "true"; isOwned := true; + isErased := true; readIdents := {}; } case Literal(IntLiteral(i)) => { @@ -773,71 +827,87 @@ module {:extern "DCOMP"} DCOMP { } isOwned := true; + isErased := true; readIdents := {}; } case Literal(DecLiteral(l)) => { s := l; isOwned := true; + isErased := true; readIdents := {}; } case Literal(StringLiteral(l)) => { // TODO(shadaj): handle unicode properly s := "\"" + l + "\".chars().collect::>()"; isOwned := true; + isErased := true; readIdents := {}; } case Literal(CharLiteral(c)) => { s := "::std::primitive::char::from_u32(" + natToString(c as nat) + ").unwrap()"; isOwned := true; + isErased := true; readIdents := {}; } case Literal(Null) => { s := "None"; isOwned := true; + isErased := true; readIdents := {}; } case Ident(name) => { s := "r#" + name; + if !(name in params) { + s := "(&" + s + ")"; + } - if name in params { - if mustOwn { - s := s + ".clone()"; - isOwned := true; - } else { - isOwned := false; - } + if mustOwn { + s := s + ".clone()"; + isOwned := true; } else { - if mustOwn { - s := s + ".clone()"; - isOwned := true; - } else { - s := "&" + s; - isOwned := false; - } + isOwned := false; } + isErased := false; + readIdents := {name}; } case Companion(path) => { s := GenPath(path); isOwned := true; + isErased := true; readIdents := {}; } case InitializationValue(typ) => { - s := "std::default::Default::default()"; + var typString := GenType(typ, false, false); + s := "<" + typString + " as std::default::Default>::default()"; isOwned := true; + isErased := false; readIdents := {}; } case Tuple(values) => { s := "("; readIdents := {}; var i := 0; + + var allErased := true; + while i < |values| { + var _, _, isErased, _ := GenExpr(values[i], params, true); + allErased := allErased && isErased; + i := i + 1; + } + + i := 0; while i < |values| { if i > 0 { s := s + " "; } - var recursiveGen, _, recIdents := GenExpr(values[i], params, true); + var recursiveGen, _, isErased, recIdents := GenExpr(values[i], params, true); + if isErased && !allErased { + recursiveGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + recursiveGen + ")"; + } + s := s + recursiveGen + ","; readIdents := readIdents + recIdents; @@ -845,6 +915,7 @@ module {:extern "DCOMP"} DCOMP { } s := s + ")"; isOwned := true; + isErased := allErased; } case New(path, args) => { var path := GenPath(path); @@ -856,7 +927,10 @@ module {:extern "DCOMP"} DCOMP { s := s + ", "; } - var recursiveGen, _, recIdents := GenExpr(args[i], params, true); + var recursiveGen, _, isErased, recIdents := GenExpr(args[i], params, true); + if isErased { + recursiveGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + recursiveGen + ")"; + } s := s + recursiveGen; readIdents := readIdents + recIdents; @@ -864,13 +938,18 @@ module {:extern "DCOMP"} DCOMP { } s := s + "))"; isOwned := true; + isErased := true; } case NewArray(dims) => { var i := |dims| - 1; s := "::std::default::Default::default()"; readIdents := {}; while i >= 0 { - var recursiveGen, _, recIdents := GenExpr(dims[i], params, true); + var recursiveGen, _, isErased, recIdents := GenExpr(dims[i], params, true); + if !isErased { + recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")"; + } + s := "vec![" + s + "; (" + recursiveGen + ") as usize]"; readIdents := readIdents + recIdents; @@ -878,6 +957,7 @@ module {:extern "DCOMP"} DCOMP { } isOwned := true; + isErased := true; } case DatatypeValue(path, variant, isCo, values) => { var path := GenPath(path); @@ -893,7 +973,12 @@ module {:extern "DCOMP"} DCOMP { } if isCo { - var recursiveGen, _, recIdents := GenExpr(value, [], true); + var recursiveGen, _, isErased, recIdents := GenExpr(value, [], true); + if !isErased { + recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")"; + } + recursiveGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + recursiveGen + ")"; + readIdents := readIdents + recIdents; var allReadCloned := ""; while recIdents != {} decreases recIdents { @@ -901,31 +986,50 @@ module {:extern "DCOMP"} DCOMP { allReadCloned := allReadCloned + "let r#" + next + " = r#" + next + ".clone();\n"; recIdents := recIdents - {next}; } - s := s + "r#" + name + ": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(Box::new({\n" + allReadCloned + "move || (" + recursiveGen + ")})))"; + s := s + "r#" + name + ": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(::std::boxed::Box::new({\n" + allReadCloned + "move || (" + recursiveGen + ")})))"; } else { - var recursiveGen, _, recIdents := GenExpr(value, params, true); - s := s + "r#" + name + ": " + recursiveGen; + var recursiveGen, _, isErased, recIdents := GenExpr(value, params, true); + if !isErased { + recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")"; + } + recursiveGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + recursiveGen + ")"; + + s := s + "r#" + name + ": " + "(" + recursiveGen + ")"; readIdents := readIdents + recIdents; } i := i + 1; } s := s + " })"; isOwned := true; + isErased := true; + } + case SubsetUpgrade(expr, tpe) => { + var tpeGen := GenType(tpe, true, false); + var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, params, false); + var uneraseFn := if recOwned then "unerase_owned" else "unerase"; + s := "<" + tpeGen + " as ::dafny_runtime::DafnyUnerasable<_>>::" + uneraseFn + "(" + recursiveGen + ")"; + isOwned := recOwned; + isErased := false; + readIdents := recIdents; } - case NewtypeValue(tpe, expr) => { - var typeString := GenType(tpe, false, false); - var recursiveGen, _, recIdents := GenExpr(expr, params, true); - s := typeString + "(" + recursiveGen + ")"; - isOwned := true; + case SubsetDowngrade(expr) => { + var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, params, false); + var eraseFn := if recOwned then "erase_owned" else "erase"; + s := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + recursiveGen + ")"; + isOwned := recOwned; + isErased := true; readIdents := recIdents; } case SeqValue(exprs) => { var generatedValues := []; readIdents := {}; var i := 0; + var allErased := true; while i < |exprs| { - var recursiveGen, _, recIdents := GenExpr(exprs[i], params, true); - generatedValues := generatedValues + [recursiveGen]; + var recursiveGen, _, isErased, recIdents := GenExpr(exprs[i], params, true); + allErased := allErased && isErased; + + generatedValues := generatedValues + [(recursiveGen, isErased)]; readIdents := readIdents + recIdents; i := i + 1; } @@ -936,20 +1040,30 @@ module {:extern "DCOMP"} DCOMP { if i > 0 { s := s + ", "; } - s := s + generatedValues[i]; + + var gen := generatedValues[i].0; + if generatedValues[i].1 && !allErased { + gen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + gen + ")"; + } + + s := s + gen; i := i + 1; } s := s + "]"; isOwned := true; + isErased := allErased; } case SetValue(exprs) => { var generatedValues := []; readIdents := {}; var i := 0; + var allErased := true; while i < |exprs| { - var recursiveGen, _, recIdents := GenExpr(exprs[i], params, true); - generatedValues := generatedValues + [recursiveGen]; + var recursiveGen, _, isErased, recIdents := GenExpr(exprs[i], params, true); + allErased := allErased && isErased; + + generatedValues := generatedValues + [(recursiveGen, isErased)]; readIdents := readIdents + recIdents; i := i + 1; } @@ -960,12 +1074,19 @@ module {:extern "DCOMP"} DCOMP { if i > 0 { s := s + ", "; } - s := s + generatedValues[i]; + + var gen := generatedValues[i].0; + if generatedValues[i].1 && !allErased { + gen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + gen + ")"; + } + + s := s + gen; i := i + 1; } s := s + "].into_iter().collect::>()"; isOwned := true; + isErased := true; } case This() => { if mustOwn { @@ -977,43 +1098,85 @@ module {:extern "DCOMP"} DCOMP { } readIdents := {"self"}; + isErased := false; } case Ite(cond, t, f) => { - var condString, _, recIdentsCond := GenExpr(cond, params, true); - var _, tHasToBeOwned, _ := GenExpr(t, params, mustOwn); // check if t has to be owned even if not requested - var fString, fOwned, recIdentsF := GenExpr(f, params, tHasToBeOwned); - var tString, _, recIdentsT := GenExpr(t, params, fOwned); // there's a chance that f forced ownership + var condString, _, condErased, recIdentsCond := GenExpr(cond, params, true); + if !condErased { + condString := "::dafny_runtime::DafnyErasable::erase_owned(" + condString + ")"; + } + + var _, tHasToBeOwned, _, _ := GenExpr(t, params, mustOwn); // check if t has to be owned even if not requested + var fString, fOwned, fErased, recIdentsF := GenExpr(f, params, tHasToBeOwned); + var tString, _, tErased, recIdentsT := GenExpr(t, params, fOwned); // there's a chance that f forced ownership + + if !fErased || !tErased { + if fErased { + fString := "::dafny_runtime::DafnyErasable::erase_owned(" + fString + ")"; + } + + if tErased { + tString := "::dafny_runtime::DafnyErasable::erase_owned(" + tString + ")"; + } + } + s := "(if " + condString + " {\n" + tString + "\n} else {\n" + fString + "\n})"; isOwned := fOwned; readIdents := recIdentsCond + recIdentsT + recIdentsF; + isErased := fErased || tErased; } case UnOp(Not, e) => { - var recursiveGen, _, recIdents := GenExpr(e, params, true); + var recursiveGen, _, recErased, recIdents := GenExpr(e, params, true); + if !recErased { + recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")"; + } + s := "!(" + recursiveGen + ")"; isOwned := true; readIdents := recIdents; + isErased := true; } case UnOp(BitwiseNot, e) => { - var recursiveGen, _, recIdents := GenExpr(e, params, true); + var recursiveGen, _, recErased, recIdents := GenExpr(e, params, true); + if !recErased { + recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")"; + } + s := "~(" + recursiveGen + ")"; isOwned := true; readIdents := recIdents; + isErased := true; } case UnOp(Cardinality, e) => { - var recursiveGen, _, recIdents := GenExpr(e, params, false); + var recursiveGen, _, recErased, recIdents := GenExpr(e, params, false); + if !recErased { + recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")"; + } + s := "(" + recursiveGen + ").len()"; isOwned := true; readIdents := recIdents; + isErased := true; } case BinOp(op, l, r) => { - var left, _, recIdentsL := GenExpr(l, params, true); - var right, _, recIdentsR := GenExpr(r, params, true); + var left, _, leftErased, recIdentsL := GenExpr(l, params, true); + var right, _, rightErased, recIdentsR := GenExpr(r, params, true); + + if !leftErased { + left := "::dafny_runtime::DafnyErasable::erase_owned(" + left + ")"; + } + + if !rightErased { + right := "::dafny_runtime::DafnyErasable::erase_owned(" + right + ")"; + } + s := "(" + left + " " + op + " " + right + ")"; isOwned := true; readIdents := recIdentsL + recIdentsR; + isErased := true; } case SelectFn(on, field, isDatatype, isStatic, arity) => { - var onString, onOwned, recIdents := GenExpr(on, params, false); + var onString, onOwned, _, recIdents := GenExpr(on, params, false); if isStatic { s := onString + "::" + field; @@ -1038,10 +1201,15 @@ module {:extern "DCOMP"} DCOMP { s := "::dafny_runtime::FunctionWrapper(" + s + ")"; isOwned := true; + isErased := true; readIdents := recIdents; } case Select(on, field, isDatatype) => { - var onString, _, recIdents := GenExpr(on, params, false); + var onString, onOwned, onErased, recIdents := GenExpr(on, params, false); + if !onErased { + var eraseFn := if onOwned then "erase_owned" else "erase"; + onString := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + onString + ")"; + } if isDatatype { s := "(" + onString + ")" + ".r#" + field + "()"; @@ -1061,10 +1229,11 @@ module {:extern "DCOMP"} DCOMP { } } + isErased := false; readIdents := recIdents; } case TupleSelect(on, idx) => { - var onString, _, recIdents := GenExpr(on, params, false); + var onString, _, tupErased, recIdents := GenExpr(on, params, false); s := "(" + onString + ")." + natToString(idx); if mustOwn { s := "(" + s + ")" + ".clone()"; @@ -1073,6 +1242,7 @@ module {:extern "DCOMP"} DCOMP { s := "&" + s; isOwned := false; } + isErased := tupErased; readIdents := recIdents; } case Call(on, name, typeArgs, args) => { @@ -1102,14 +1272,18 @@ module {:extern "DCOMP"} DCOMP { argString := argString + ", "; } - var argExpr, isOwned, recIdents := GenExpr(args[i], params, false); - readIdents := readIdents + recIdents; - argString := argString + (if isOwned then "&" else "") + argExpr; + var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], params, false); + if isOwned { + argExpr := "&" + argExpr; + } + + argString := argString + argExpr; + readIdents := readIdents + argIdents; i := i + 1; } - var enclosingString, _, recIdents := GenExpr(on, params, false); + var enclosingString, _, _, recIdents := GenExpr(on, params, false); readIdents := readIdents + recIdents; match on { case Companion(_) => { @@ -1122,8 +1296,9 @@ module {:extern "DCOMP"} DCOMP { s := enclosingString + "r#" + name.id + typeArgString + "(" + argString + ")"; isOwned := true; + isErased := false; } - case Lambda(params, body) => { + case Lambda(params, retType, body) => { var paramNames := []; var i := 0; while i < |params| { @@ -1131,7 +1306,7 @@ module {:extern "DCOMP"} DCOMP { i := i + 1; } - var recursiveGen, recIdents := GenStmts(body, paramNames, ""); + var recursiveGen, recIdents := GenStmts(body, paramNames, true, ""); readIdents := {}; var allReadCloned := ""; while recIdents != {} decreases recIdents { @@ -1158,21 +1333,32 @@ module {:extern "DCOMP"} DCOMP { i := i + 1; } - s := "::dafny_runtime::FunctionWrapper({\n" + allReadCloned + "Box::new(move |" + paramsString + "| {\n" + recursiveGen + "\n})})"; + var retTypeGen := GenType(retType, false, true); + + s := "::dafny_runtime::FunctionWrapper({\n" + allReadCloned + "::std::boxed::Box::new(move |" + paramsString + "| -> " + retTypeGen + " {\n" + recursiveGen + "\n})})"; isOwned := true; + isErased := true; } case IIFE(name, tpe, value, iifeBody) => { - var valueGen, valueOwned, recIdents := GenExpr(value, params, false); + var valueGen, valueOwned, valueErased, recIdents := GenExpr(value, params, false); + if valueErased { + var eraseFn := if valueOwned then "unerase_owned" else "unerase"; + valueGen := "::dafny_runtime::DafnyUnerasable::<_>::" + eraseFn + "(" + valueGen + ")"; + } + readIdents := recIdents; var valueTypeGen := GenType(tpe, false, true); - var bodyGen, bodyOwned, bodyIdents := GenExpr(iifeBody, params + if valueOwned then [] else [name.id], mustOwn); + var bodyGen, bodyOwned, bodyErased, bodyIdents := GenExpr(iifeBody, params + if valueOwned then [] else [name.id], mustOwn); readIdents := readIdents + bodyIdents; + var eraseFn := if valueOwned then "unerase_owned" else "unerase"; + s := "{\nlet r#" + name.id + ": " + (if valueOwned then "" else "&") + valueTypeGen + " = " + valueGen + ";\n" + bodyGen + "\n}"; isOwned := bodyOwned; + isErased := bodyErased; } case Apply(func, args) => { - var funcString, _, recIdents := GenExpr(func, params, false); + var funcString, _, funcErased, recIdents := GenExpr(func, params, false); readIdents := recIdents; var argString := ""; @@ -1182,21 +1368,27 @@ module {:extern "DCOMP"} DCOMP { argString := argString + ", "; } - var argExpr, isOwned, recIdents := GenExpr(args[i], params, false); - readIdents := readIdents + recIdents; - argString := argString + (if isOwned then "&" else "") + argExpr; + var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], params, false); + if isOwned { + argExpr := "&" + argExpr; + } + + argString := argString + argExpr; + readIdents := readIdents + argIdents; i := i + 1; } s := "((" + funcString + ").0" + "(" + argString + "))"; isOwned := true; + isErased := false; } case TypeTest(on, dType, variant) => { - var exprGen, _, recIdents := GenExpr(on, params, false); + var exprGen, _, exprErased, recIdents := GenExpr(on, params, false); var dTypePath := GenPath(dType); s := "matches!(" + exprGen + ".as_ref(), " + dTypePath + "::r#" + variant + "{ .. })"; isOwned := true; + isErased := true; readIdents := recIdents; } } diff --git a/Source/DafnyCore/GeneratedFromDafnyRust.cs b/Source/DafnyCore/GeneratedFromDafnyRust.cs index fa4c635e834..801e8fa15e2 100644 --- a/Source/DafnyCore/GeneratedFromDafnyRust.cs +++ b/Source/DafnyCore/GeneratedFromDafnyRust.cs @@ -290,32 +290,40 @@ public override string ToString() { public interface _INewtype { bool is_Newtype { get; } Dafny.ISequence dtor_name { get; } + Dafny.ISequence dtor_typeParams { get; } DAST._IType dtor_base { get; } + Dafny.ISequence dtor_witnessStmts { get; } DAST._IOptional dtor_witnessExpr { get; } _INewtype DowncastClone(); } public class Newtype : _INewtype { public readonly Dafny.ISequence _name; + public readonly Dafny.ISequence _typeParams; public readonly DAST._IType _base; + public readonly Dafny.ISequence _witnessStmts; public readonly DAST._IOptional _witnessExpr; - public Newtype(Dafny.ISequence name, DAST._IType @base, DAST._IOptional witnessExpr) { + public Newtype(Dafny.ISequence name, Dafny.ISequence typeParams, DAST._IType @base, Dafny.ISequence witnessStmts, DAST._IOptional witnessExpr) { this._name = name; + this._typeParams = typeParams; this._base = @base; + this._witnessStmts = witnessStmts; this._witnessExpr = witnessExpr; } public _INewtype DowncastClone() { if (this is _INewtype dt) { return dt; } - return new Newtype(_name, _base, _witnessExpr); + return new Newtype(_name, _typeParams, _base, _witnessStmts, _witnessExpr); } public override bool Equals(object other) { var oth = other as DAST.Newtype; - return oth != null && object.Equals(this._name, oth._name) && object.Equals(this._base, oth._base) && object.Equals(this._witnessExpr, oth._witnessExpr); + return oth != null && object.Equals(this._name, oth._name) && object.Equals(this._typeParams, oth._typeParams) && object.Equals(this._base, oth._base) && object.Equals(this._witnessStmts, oth._witnessStmts) && object.Equals(this._witnessExpr, oth._witnessExpr); } public override int GetHashCode() { ulong hash = 5381; hash = ((hash << 5) + hash) + 0; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._name)); + hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._typeParams)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._base)); + hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._witnessStmts)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._witnessExpr)); return (int)hash; } @@ -324,13 +332,17 @@ public override string ToString() { s += "("; s += this._name.ToVerbatimString(true); s += ", "; + s += Dafny.Helpers.ToString(this._typeParams); + s += ", "; s += Dafny.Helpers.ToString(this._base); s += ", "; + s += Dafny.Helpers.ToString(this._witnessStmts); + s += ", "; s += Dafny.Helpers.ToString(this._witnessExpr); s += ")"; return s; } - private static readonly DAST._INewtype theDefault = create(Dafny.Sequence.Empty, DAST.Type.Default(), DAST.Optional.Default()); + private static readonly DAST._INewtype theDefault = create(Dafny.Sequence.Empty, Dafny.Sequence.Empty, DAST.Type.Default(), Dafny.Sequence.Empty, DAST.Optional.Default()); public static DAST._INewtype Default() { return theDefault; } @@ -338,11 +350,11 @@ public static DAST._INewtype Default() { public static Dafny.TypeDescriptor _TypeDescriptor() { return _TYPE; } - public static _INewtype create(Dafny.ISequence name, DAST._IType @base, DAST._IOptional witnessExpr) { - return new Newtype(name, @base, witnessExpr); + public static _INewtype create(Dafny.ISequence name, Dafny.ISequence typeParams, DAST._IType @base, Dafny.ISequence witnessStmts, DAST._IOptional witnessExpr) { + return new Newtype(name, typeParams, @base, witnessStmts, witnessExpr); } - public static _INewtype create_Newtype(Dafny.ISequence name, DAST._IType @base, DAST._IOptional witnessExpr) { - return create(name, @base, witnessExpr); + public static _INewtype create_Newtype(Dafny.ISequence name, Dafny.ISequence typeParams, DAST._IType @base, Dafny.ISequence witnessStmts, DAST._IOptional witnessExpr) { + return create(name, typeParams, @base, witnessStmts, witnessExpr); } public bool is_Newtype { get { return true; } } public Dafny.ISequence dtor_name { @@ -350,11 +362,21 @@ public Dafny.ISequence dtor_name { return this._name; } } + public Dafny.ISequence dtor_typeParams { + get { + return this._typeParams; + } + } public DAST._IType dtor_base { get { return this._base; } } + public Dafny.ISequence dtor_witnessStmts { + get { + return this._witnessStmts; + } + } public DAST._IOptional dtor_witnessExpr { get { return this._witnessExpr; @@ -2271,7 +2293,8 @@ public interface _IExpression { bool is_New { get; } bool is_NewArray { get; } bool is_DatatypeValue { get; } - bool is_NewtypeValue { get; } + bool is_SubsetUpgrade { get; } + bool is_SubsetDowngrade { get; } bool is_SeqValue { get; } bool is_SetValue { get; } bool is_This { get; } @@ -2297,8 +2320,8 @@ public interface _IExpression { Dafny.ISequence dtor_variant { get; } bool dtor_isCo { get; } Dafny.ISequence<_System._ITuple2, DAST._IExpression>> dtor_contents { get; } - DAST._IType dtor_tpe { get; } DAST._IExpression dtor_value { get; } + DAST._IType dtor_typ { get; } Dafny.ISequence dtor_elements { get; } DAST._IExpression dtor_cond { get; } DAST._IExpression dtor_thn { get; } @@ -2317,8 +2340,8 @@ public interface _IExpression { Dafny.ISequence dtor_name { get; } Dafny.ISequence dtor_typeArgs { get; } Dafny.ISequence dtor_params { get; } + DAST._IType dtor_retType { get; } Dafny.ISequence dtor_body { get; } - DAST._IType dtor_typ { get; } DAST._IExpression dtor_iifeBody { get; } Dafny.ISequence> dtor_dType { get; } _IExpression DowncastClone(); @@ -2355,8 +2378,11 @@ public static _IExpression create_NewArray(Dafny.ISequence di public static _IExpression create_DatatypeValue(Dafny.ISequence> path, Dafny.ISequence variant, bool isCo, Dafny.ISequence<_System._ITuple2, DAST._IExpression>> contents) { return new Expression_DatatypeValue(path, variant, isCo, contents); } - public static _IExpression create_NewtypeValue(DAST._IType tpe, DAST._IExpression @value) { - return new Expression_NewtypeValue(tpe, @value); + public static _IExpression create_SubsetUpgrade(DAST._IExpression @value, DAST._IType typ) { + return new Expression_SubsetUpgrade(@value, typ); + } + public static _IExpression create_SubsetDowngrade(DAST._IExpression @value) { + return new Expression_SubsetDowngrade(@value); } public static _IExpression create_SeqValue(Dafny.ISequence elements) { return new Expression_SeqValue(elements); @@ -2388,8 +2414,8 @@ public static _IExpression create_TupleSelect(DAST._IExpression expr, BigInteger public static _IExpression create_Call(DAST._IExpression @on, Dafny.ISequence name, Dafny.ISequence typeArgs, Dafny.ISequence args) { return new Expression_Call(@on, name, typeArgs, args); } - public static _IExpression create_Lambda(Dafny.ISequence @params, Dafny.ISequence body) { - return new Expression_Lambda(@params, body); + public static _IExpression create_Lambda(Dafny.ISequence @params, DAST._IType retType, Dafny.ISequence body) { + return new Expression_Lambda(@params, retType, body); } public static _IExpression create_IIFE(Dafny.ISequence name, DAST._IType typ, DAST._IExpression @value, DAST._IExpression iifeBody) { return new Expression_IIFE(name, typ, @value, iifeBody); @@ -2410,7 +2436,8 @@ public static _IExpression create_InitializationValue(DAST._IType typ) { public bool is_New { get { return this is Expression_New; } } public bool is_NewArray { get { return this is Expression_NewArray; } } public bool is_DatatypeValue { get { return this is Expression_DatatypeValue; } } - public bool is_NewtypeValue { get { return this is Expression_NewtypeValue; } } + public bool is_SubsetUpgrade { get { return this is Expression_SubsetUpgrade; } } + public bool is_SubsetDowngrade { get { return this is Expression_SubsetDowngrade; } } public bool is_SeqValue { get { return this is Expression_SeqValue; } } public bool is_SetValue { get { return this is Expression_SetValue; } } public bool is_This { get { return this is Expression_This; } } @@ -2490,17 +2517,20 @@ public bool dtor_isCo { return ((Expression_DatatypeValue)d)._contents; } } - public DAST._IType dtor_tpe { + public DAST._IExpression dtor_value { get { var d = this; - return ((Expression_NewtypeValue)d)._tpe; + if (d is Expression_SubsetUpgrade) { return ((Expression_SubsetUpgrade)d)._value; } + if (d is Expression_SubsetDowngrade) { return ((Expression_SubsetDowngrade)d)._value; } + return ((Expression_IIFE)d)._value; } } - public DAST._IExpression dtor_value { + public DAST._IType dtor_typ { get { var d = this; - if (d is Expression_NewtypeValue) { return ((Expression_NewtypeValue)d)._value; } - return ((Expression_IIFE)d)._value; + if (d is Expression_SubsetUpgrade) { return ((Expression_SubsetUpgrade)d)._typ; } + if (d is Expression_IIFE) { return ((Expression_IIFE)d)._typ; } + return ((Expression_InitializationValue)d)._typ; } } public Dafny.ISequence dtor_elements { @@ -2620,17 +2650,16 @@ public Dafny.ISequence dtor_params { return ((Expression_Lambda)d)._params; } } - public Dafny.ISequence dtor_body { + public DAST._IType dtor_retType { get { var d = this; - return ((Expression_Lambda)d)._body; + return ((Expression_Lambda)d)._retType; } } - public DAST._IType dtor_typ { + public Dafny.ISequence dtor_body { get { var d = this; - if (d is Expression_IIFE) { return ((Expression_IIFE)d)._typ; } - return ((Expression_InitializationValue)d)._typ; + return ((Expression_Lambda)d)._body; } } public DAST._IExpression dtor_iifeBody { @@ -2856,33 +2885,60 @@ public override string ToString() { return s; } } - public class Expression_NewtypeValue : Expression { - public readonly DAST._IType _tpe; + public class Expression_SubsetUpgrade : Expression { public readonly DAST._IExpression _value; - public Expression_NewtypeValue(DAST._IType tpe, DAST._IExpression @value) : base() { - this._tpe = tpe; + public readonly DAST._IType _typ; + public Expression_SubsetUpgrade(DAST._IExpression @value, DAST._IType typ) : base() { this._value = @value; + this._typ = typ; } public override _IExpression DowncastClone() { if (this is _IExpression dt) { return dt; } - return new Expression_NewtypeValue(_tpe, _value); + return new Expression_SubsetUpgrade(_value, _typ); } public override bool Equals(object other) { - var oth = other as DAST.Expression_NewtypeValue; - return oth != null && object.Equals(this._tpe, oth._tpe) && object.Equals(this._value, oth._value); + var oth = other as DAST.Expression_SubsetUpgrade; + return oth != null && object.Equals(this._value, oth._value) && object.Equals(this._typ, oth._typ); } public override int GetHashCode() { ulong hash = 5381; hash = ((hash << 5) + hash) + 7; - hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._tpe)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._value)); + hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._typ)); return (int)hash; } public override string ToString() { - string s = "DAST.Expression.NewtypeValue"; + string s = "DAST.Expression.SubsetUpgrade"; s += "("; - s += Dafny.Helpers.ToString(this._tpe); + s += Dafny.Helpers.ToString(this._value); s += ", "; + s += Dafny.Helpers.ToString(this._typ); + s += ")"; + return s; + } + } + public class Expression_SubsetDowngrade : Expression { + public readonly DAST._IExpression _value; + public Expression_SubsetDowngrade(DAST._IExpression @value) : base() { + this._value = @value; + } + public override _IExpression DowncastClone() { + if (this is _IExpression dt) { return dt; } + return new Expression_SubsetDowngrade(_value); + } + public override bool Equals(object other) { + var oth = other as DAST.Expression_SubsetDowngrade; + return oth != null && object.Equals(this._value, oth._value); + } + public override int GetHashCode() { + ulong hash = 5381; + hash = ((hash << 5) + hash) + 8; + hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._value)); + return (int)hash; + } + public override string ToString() { + string s = "DAST.Expression.SubsetDowngrade"; + s += "("; s += Dafny.Helpers.ToString(this._value); s += ")"; return s; @@ -2903,7 +2959,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 8; + hash = ((hash << 5) + hash) + 9; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._elements)); return (int)hash; } @@ -2930,7 +2986,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 9; + hash = ((hash << 5) + hash) + 10; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._elements)); return (int)hash; } @@ -2955,7 +3011,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 10; + hash = ((hash << 5) + hash) + 11; return (int)hash; } public override string ToString() { @@ -2982,7 +3038,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 11; + hash = ((hash << 5) + hash) + 12; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._cond)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._thn)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._els)); @@ -3017,7 +3073,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 12; + hash = ((hash << 5) + hash) + 13; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._unOp)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._expr)); return (int)hash; @@ -3051,7 +3107,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 13; + hash = ((hash << 5) + hash) + 14; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._op)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._left)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._right)); @@ -3088,7 +3144,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 14; + hash = ((hash << 5) + hash) + 15; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._expr)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._field)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._onDatatype)); @@ -3129,7 +3185,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 15; + hash = ((hash << 5) + hash) + 16; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._expr)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._field)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._onDatatype)); @@ -3170,7 +3226,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 16; + hash = ((hash << 5) + hash) + 17; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._expr)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._index)); return (int)hash; @@ -3206,7 +3262,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 17; + hash = ((hash << 5) + hash) + 18; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._on)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._name)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._typeArgs)); @@ -3229,23 +3285,26 @@ public override string ToString() { } public class Expression_Lambda : Expression { public readonly Dafny.ISequence _params; + public readonly DAST._IType _retType; public readonly Dafny.ISequence _body; - public Expression_Lambda(Dafny.ISequence @params, Dafny.ISequence body) : base() { + public Expression_Lambda(Dafny.ISequence @params, DAST._IType retType, Dafny.ISequence body) : base() { this._params = @params; + this._retType = retType; this._body = body; } public override _IExpression DowncastClone() { if (this is _IExpression dt) { return dt; } - return new Expression_Lambda(_params, _body); + return new Expression_Lambda(_params, _retType, _body); } public override bool Equals(object other) { var oth = other as DAST.Expression_Lambda; - return oth != null && object.Equals(this._params, oth._params) && object.Equals(this._body, oth._body); + return oth != null && object.Equals(this._params, oth._params) && object.Equals(this._retType, oth._retType) && object.Equals(this._body, oth._body); } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 18; + hash = ((hash << 5) + hash) + 19; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._params)); + hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._retType)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._body)); return (int)hash; } @@ -3254,6 +3313,8 @@ public override string ToString() { s += "("; s += Dafny.Helpers.ToString(this._params); s += ", "; + s += Dafny.Helpers.ToString(this._retType); + s += ", "; s += Dafny.Helpers.ToString(this._body); s += ")"; return s; @@ -3280,7 +3341,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 19; + hash = ((hash << 5) + hash) + 20; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._name)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._typ)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._value)); @@ -3318,7 +3379,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 20; + hash = ((hash << 5) + hash) + 21; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._expr)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._args)); return (int)hash; @@ -3352,7 +3413,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 21; + hash = ((hash << 5) + hash) + 22; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._on)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._dType)); hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._variant)); @@ -3385,7 +3446,7 @@ public override bool Equals(object other) { } public override int GetHashCode() { ulong hash = 5381; - hash = ((hash << 5) + hash) + 22; + hash = ((hash << 5) + hash) + 23; hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._typ)); return (int)hash; } @@ -3935,7 +3996,7 @@ public COMP() { Dafny.ISequence _out11; _out11 = DCOMP.COMP.GenType(_43_tp, false, false); _44_genTp = _out11; - _41_typeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_41_typeParams, Dafny.Sequence.UnicodeFromString("r#")), _44_genTp), Dafny.Sequence.UnicodeFromString(", ")); + _41_typeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_41_typeParams, _44_genTp), Dafny.Sequence.UnicodeFromString(", ")); _42_tpI = (_42_tpI) + (BigInteger.One); } _41_typeParams = Dafny.Sequence.Concat(_41_typeParams, Dafny.Sequence.UnicodeFromString(">")); @@ -3954,29 +4015,83 @@ public COMP() { } public static Dafny.ISequence GenNewtype(DAST._INewtype c) { Dafny.ISequence s = Dafny.Sequence.Empty; - Dafny.ISequence _48_underlyingType; - Dafny.ISequence _out14; - _out14 = DCOMP.COMP.GenType((c).dtor_base, false, false); - _48_underlyingType = _out14; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("#[derive(Clone, PartialEq)]\npub struct r#"), (c).dtor_name), Dafny.Sequence.UnicodeFromString("(pub ")), _48_underlyingType), Dafny.Sequence.UnicodeFromString(");\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ::std::default::Default for r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString(" {\n")); + Dafny.ISet _48_typeParamsSet; + _48_typeParamsSet = Dafny.Set.FromElements(); + Dafny.ISequence _49_typeParams; + _49_typeParams = Dafny.Sequence.UnicodeFromString(""); + Dafny.ISequence _50_constrainedTypeParams; + _50_constrainedTypeParams = Dafny.Sequence.UnicodeFromString(""); + BigInteger _51_tpI; + _51_tpI = BigInteger.Zero; + if ((new BigInteger(((c).dtor_typeParams).Count)).Sign == 1) { + _49_typeParams = Dafny.Sequence.UnicodeFromString("<"); + _50_constrainedTypeParams = Dafny.Sequence.UnicodeFromString("<"); + while ((_51_tpI) < (new BigInteger(((c).dtor_typeParams).Count))) { + DAST._IType _52_tp; + _52_tp = ((c).dtor_typeParams).Select(_51_tpI); + _48_typeParamsSet = Dafny.Set.Union(_48_typeParamsSet, Dafny.Set.FromElements(_52_tp)); + Dafny.ISequence _53_genTp; + Dafny.ISequence _out14; + _out14 = DCOMP.COMP.GenType(_52_tp, false, false); + _53_genTp = _out14; + _49_typeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_49_typeParams, _53_genTp), Dafny.Sequence.UnicodeFromString(", ")); + _50_constrainedTypeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_50_constrainedTypeParams, _53_genTp), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<")), _53_genTp), Dafny.Sequence.UnicodeFromString("> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static, ")); + _51_tpI = (_51_tpI) + (BigInteger.One); + } + _49_typeParams = Dafny.Sequence.Concat(_49_typeParams, Dafny.Sequence.UnicodeFromString(">")); + _50_constrainedTypeParams = Dafny.Sequence.Concat(_50_constrainedTypeParams, Dafny.Sequence.UnicodeFromString(">")); + } + Dafny.ISequence _54_underlyingType; + Dafny.ISequence _out15; + _out15 = DCOMP.COMP.GenType((c).dtor_base, false, false); + _54_underlyingType = _out15; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("#[derive(Clone, PartialEq)]\n#[repr(transparent)]\npub struct r#"), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString("(pub ")), _54_underlyingType), Dafny.Sequence.UnicodeFromString(");\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ")), _50_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyErasable for r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("type Erased = ")), _54_underlyingType), Dafny.Sequence.UnicodeFromString(";\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("#[inline]\nfn erase(&self) -> &Self::Erased {\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("&self.0\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("#[inline]\nfn erase_owned(self) -> Self::Erased {\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("self.0\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ")), _50_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<")), _54_underlyingType), Dafny.Sequence.UnicodeFromString("> for r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("#[inline]\nfn unerase(x: &")), _54_underlyingType), Dafny.Sequence.UnicodeFromString(") -> &Self {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("unsafe { &*(x as *const ")), _54_underlyingType), Dafny.Sequence.UnicodeFromString(" as *const r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(") }\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("#[inline]\nfn unerase_owned(x: ")), _54_underlyingType), Dafny.Sequence.UnicodeFromString(") -> Self {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("(x)\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ")), _50_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable.UnicodeFromString("> for r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("#[inline]\nfn unerase(x: &r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(") -> &Self {\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("x\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("#[inline]\nfn unerase_owned(x: r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(") -> Self {\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("x\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ")), _50_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("fn default() -> Self {\n")); DAST._IOptional _source3 = (c).dtor_witnessExpr; if (_source3.is_Some) { - DAST._IExpression _49___mcc_h0 = _source3.dtor_Some_a0; - DAST._IExpression _50_e = _49___mcc_h0; + DAST._IExpression _55___mcc_h0 = _source3.dtor_Some_a0; + DAST._IExpression _56_e = _55___mcc_h0; { - Dafny.ISequence _51_eStr; - bool _52___v4; - Dafny.ISet> _53___v5; - Dafny.ISequence _out15; - bool _out16; - Dafny.ISet> _out17; - DCOMP.COMP.GenExpr(_50_e, Dafny.Sequence>.FromElements(), true, out _out15, out _out16, out _out17); - _51_eStr = _out15; - _52___v4 = _out16; - _53___v5 = _out17; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("(")), _51_eStr), Dafny.Sequence.UnicodeFromString(")\n")); + Dafny.ISequence _57_eStr; + bool _58___v4; + bool _59___v5; + Dafny.ISet> _60___v6; + Dafny.ISequence _out16; + bool _out17; + bool _out18; + Dafny.ISet> _out19; + DCOMP.COMP.GenExpr(_56_e, Dafny.Sequence>.FromElements(), true, out _out16, out _out17, out _out18, out _out19); + _57_eStr = _out16; + _58___v4 = _out17; + _59___v5 = _out18; + _60___v6 = _out19; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("(")), _57_eStr), Dafny.Sequence.UnicodeFromString(")\n")); } } else { { @@ -3985,224 +4100,204 @@ public COMP() { } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString(" {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ")), _50_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _49_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, in_seq: bool) -> ::std::fmt::Result {\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyPrint::fmt_print(&self.0, __fmt_print_formatter, in_seq)\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}")); - Dafny.ISequence<_System._ITuple2, Dafny.ISequence>> _54_ops; - _54_ops = Dafny.Sequence<_System._ITuple2, Dafny.ISequence>>.FromElements(_System.Tuple2, Dafny.ISequence>.create(Dafny.Sequence.UnicodeFromString("::std::ops::Add"), Dafny.Sequence.UnicodeFromString("add")), _System.Tuple2, Dafny.ISequence>.create(Dafny.Sequence.UnicodeFromString("::std::ops::Sub"), Dafny.Sequence.UnicodeFromString("sub")), _System.Tuple2, Dafny.ISequence>.create(Dafny.Sequence.UnicodeFromString("::std::ops::Mul"), Dafny.Sequence.UnicodeFromString("mul")), _System.Tuple2, Dafny.ISequence>.create(Dafny.Sequence.UnicodeFromString("::std::ops::Div"), Dafny.Sequence.UnicodeFromString("div"))); - BigInteger _55_i; - _55_i = BigInteger.Zero; - while ((_55_i) < (new BigInteger((_54_ops).Count))) { - _System._ITuple2, Dafny.ISequence> _let_tmp_rhs0 = (_54_ops).Select(_55_i); - Dafny.ISequence _56_traitName = _let_tmp_rhs0.dtor__0; - Dafny.ISequence _57_methodName = _let_tmp_rhs0.dtor__1; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ")), _56_traitName), Dafny.Sequence.UnicodeFromString(".UnicodeFromString("> for r#")), (c).dtor_name); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" where ")), _48_underlyingType), Dafny.Sequence.UnicodeFromString(": ")), _56_traitName), Dafny.Sequence.UnicodeFromString("<")), _48_underlyingType), Dafny.Sequence.UnicodeFromString(", Output = ")), _48_underlyingType), Dafny.Sequence.UnicodeFromString("> {\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("type Output = r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString(";\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("fn ")), _57_methodName), Dafny.Sequence.UnicodeFromString("(self, other: r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString(") -> r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString(" {\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("(")), _56_traitName), Dafny.Sequence.UnicodeFromString("::")), _57_methodName), Dafny.Sequence.UnicodeFromString("(self.0, other.0))\n")); - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); - _55_i = (_55_i) + (BigInteger.One); - } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("impl ::std::cmp::PartialOrd.UnicodeFromString("> for r#")), (c).dtor_name); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" where ")), _48_underlyingType), Dafny.Sequence.UnicodeFromString(": ::std::cmp::PartialOrd<")), _48_underlyingType), Dafny.Sequence.UnicodeFromString("> {\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("fn partial_cmp(&self, other: &r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString(") -> ::std::option::Option<::std::cmp::Ordering> {\n")); - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("self.0.partial_cmp(&other.0)\n")); - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); return s; } public static Dafny.ISequence GenDatatype(DAST._IDatatype c) { Dafny.ISequence s = Dafny.Sequence.Empty; - Dafny.ISet _58_typeParamsSet; - _58_typeParamsSet = Dafny.Set.FromElements(); - Dafny.ISequence _59_typeParams; - _59_typeParams = Dafny.Sequence.UnicodeFromString(""); - BigInteger _60_tpI; - _60_tpI = BigInteger.Zero; + Dafny.ISet _61_typeParamsSet; + _61_typeParamsSet = Dafny.Set.FromElements(); + Dafny.ISequence _62_typeParams; + _62_typeParams = Dafny.Sequence.UnicodeFromString(""); + BigInteger _63_tpI; + _63_tpI = BigInteger.Zero; if ((new BigInteger(((c).dtor_typeParams).Count)).Sign == 1) { - _59_typeParams = Dafny.Sequence.UnicodeFromString("<"); - while ((_60_tpI) < (new BigInteger(((c).dtor_typeParams).Count))) { - DAST._IType _61_tp; - _61_tp = ((c).dtor_typeParams).Select(_60_tpI); - _58_typeParamsSet = Dafny.Set.Union(_58_typeParamsSet, Dafny.Set.FromElements(_61_tp)); - Dafny.ISequence _62_genTp; - Dafny.ISequence _out18; - _out18 = DCOMP.COMP.GenType(_61_tp, false, false); - _62_genTp = _out18; - _59_typeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_59_typeParams, Dafny.Sequence.UnicodeFromString("r#")), _62_genTp), Dafny.Sequence.UnicodeFromString(", ")); - _60_tpI = (_60_tpI) + (BigInteger.One); + _62_typeParams = Dafny.Sequence.UnicodeFromString("<"); + while ((_63_tpI) < (new BigInteger(((c).dtor_typeParams).Count))) { + DAST._IType _64_tp; + _64_tp = ((c).dtor_typeParams).Select(_63_tpI); + _61_typeParamsSet = Dafny.Set.Union(_61_typeParamsSet, Dafny.Set.FromElements(_64_tp)); + Dafny.ISequence _65_genTp; + Dafny.ISequence _out20; + _out20 = DCOMP.COMP.GenType(_64_tp, false, false); + _65_genTp = _out20; + _62_typeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_62_typeParams, _65_genTp), Dafny.Sequence.UnicodeFromString(", ")); + _63_tpI = (_63_tpI) + (BigInteger.One); } - _59_typeParams = Dafny.Sequence.Concat(_59_typeParams, Dafny.Sequence.UnicodeFromString(">")); - } - Dafny.ISequence _63_ctors; - _63_ctors = Dafny.Sequence.UnicodeFromString(""); - BigInteger _64_i; - _64_i = BigInteger.Zero; - while ((_64_i) < (new BigInteger(((c).dtor_ctors).Count))) { - DAST._IDatatypeCtor _65_ctor; - _65_ctor = ((c).dtor_ctors).Select(_64_i); - Dafny.ISequence _66_ctorBody; - _66_ctorBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), (_65_ctor).dtor_name), Dafny.Sequence.UnicodeFromString(" { ")); - BigInteger _67_j; - _67_j = BigInteger.Zero; - while ((_67_j) < (new BigInteger(((_65_ctor).dtor_args).Count))) { - DAST._IFormal _68_formal; - _68_formal = ((_65_ctor).dtor_args).Select(_67_j); - Dafny.ISequence _69_formalType; - Dafny.ISequence _out19; - _out19 = DCOMP.COMP.GenType((_68_formal).dtor_typ, false, false); - _69_formalType = _out19; + _62_typeParams = Dafny.Sequence.Concat(_62_typeParams, Dafny.Sequence.UnicodeFromString(">")); + } + Dafny.ISequence _66_ctors; + _66_ctors = Dafny.Sequence.UnicodeFromString(""); + BigInteger _67_i; + _67_i = BigInteger.Zero; + while ((_67_i) < (new BigInteger(((c).dtor_ctors).Count))) { + DAST._IDatatypeCtor _68_ctor; + _68_ctor = ((c).dtor_ctors).Select(_67_i); + Dafny.ISequence _69_ctorBody; + _69_ctorBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), (_68_ctor).dtor_name), Dafny.Sequence.UnicodeFromString(" { ")); + BigInteger _70_j; + _70_j = BigInteger.Zero; + while ((_70_j) < (new BigInteger(((_68_ctor).dtor_args).Count))) { + DAST._IFormal _71_formal; + _71_formal = ((_68_ctor).dtor_args).Select(_70_j); + Dafny.ISequence _72_formalType; + Dafny.ISequence _out21; + _out21 = DCOMP.COMP.GenType((_71_formal).dtor_typ, false, false); + _72_formalType = _out21; if ((c).dtor_isCo) { - _66_ctorBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_66_ctorBody, Dafny.Sequence.UnicodeFromString("r#")), (_68_formal).dtor_name), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper<")), _69_formalType), Dafny.Sequence.UnicodeFromString(">, ")); + _69_ctorBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_69_ctorBody, Dafny.Sequence.UnicodeFromString("r#")), (_71_formal).dtor_name), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper<")), _72_formalType), Dafny.Sequence.UnicodeFromString(">, ")); } else { - _66_ctorBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_66_ctorBody, Dafny.Sequence.UnicodeFromString("r#")), (_68_formal).dtor_name), Dafny.Sequence.UnicodeFromString(": ")), _69_formalType), Dafny.Sequence.UnicodeFromString(", ")); + _69_ctorBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_69_ctorBody, Dafny.Sequence.UnicodeFromString("r#")), (_71_formal).dtor_name), Dafny.Sequence.UnicodeFromString(": ")), _72_formalType), Dafny.Sequence.UnicodeFromString(", ")); } - _67_j = (_67_j) + (BigInteger.One); + _70_j = (_70_j) + (BigInteger.One); } - _66_ctorBody = Dafny.Sequence.Concat(_66_ctorBody, Dafny.Sequence.UnicodeFromString("}")); - _63_ctors = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_63_ctors, _66_ctorBody), Dafny.Sequence.UnicodeFromString(",\n")); - _64_i = (_64_i) + (BigInteger.One); - } - Dafny.ISequence> _70_selfPath; - _70_selfPath = Dafny.Sequence>.FromElements((c).dtor_name); - Dafny.ISequence _71_implBody; - Dafny.IMap>, Dafny.ISequence> _72_traitBodies; - Dafny.ISequence _out20; - Dafny.IMap>, Dafny.ISequence> _out21; - DCOMP.COMP.GenClassImplBody((c).dtor_body, false, DAST.Type.create_Path(Dafny.Sequence>.FromElements(), Dafny.Sequence.FromElements(), DAST.ResolvedType.create_Datatype(_70_selfPath)), _58_typeParamsSet, out _out20, out _out21); - _71_implBody = _out20; - _72_traitBodies = _out21; - _64_i = BigInteger.Zero; - Dafny.ISet> _73_emittedFields; - _73_emittedFields = Dafny.Set>.FromElements(); - while ((_64_i) < (new BigInteger(((c).dtor_ctors).Count))) { - DAST._IDatatypeCtor _74_ctor; - _74_ctor = ((c).dtor_ctors).Select(_64_i); - BigInteger _75_j; - _75_j = BigInteger.Zero; - while ((_75_j) < (new BigInteger(((_74_ctor).dtor_args).Count))) { - DAST._IFormal _76_formal; - _76_formal = ((_74_ctor).dtor_args).Select(_75_j); - if (!((_73_emittedFields).Contains((_76_formal).dtor_name))) { - _73_emittedFields = Dafny.Set>.Union(_73_emittedFields, Dafny.Set>.FromElements((_76_formal).dtor_name)); - Dafny.ISequence _77_formalType; - Dafny.ISequence _out22; - _out22 = DCOMP.COMP.GenType((_76_formal).dtor_typ, false, false); - _77_formalType = _out22; - Dafny.ISequence _78_methodBody; - _78_methodBody = Dafny.Sequence.UnicodeFromString("match self {\n"); - BigInteger _79_k; - _79_k = BigInteger.Zero; - while ((_79_k) < (new BigInteger(((c).dtor_ctors).Count))) { - DAST._IDatatypeCtor _80_ctor2; - _80_ctor2 = ((c).dtor_ctors).Select(_79_k); - Dafny.ISequence _81_ctorMatch; - _81_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), (c).dtor_name), Dafny.Sequence.UnicodeFromString("::")), Dafny.Sequence.UnicodeFromString("r#")), (_80_ctor2).dtor_name), Dafny.Sequence.UnicodeFromString(" { ")); - BigInteger _82_l; - _82_l = BigInteger.Zero; - bool _83_hasMatchingField; - _83_hasMatchingField = false; - while ((_82_l) < (new BigInteger(((_80_ctor2).dtor_args).Count))) { - DAST._IFormal _84_formal2; - _84_formal2 = ((_80_ctor2).dtor_args).Select(_82_l); - if (((_76_formal).dtor_name).Equals((_84_formal2).dtor_name)) { - _83_hasMatchingField = true; + _69_ctorBody = Dafny.Sequence.Concat(_69_ctorBody, Dafny.Sequence.UnicodeFromString("}")); + _66_ctors = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_66_ctors, _69_ctorBody), Dafny.Sequence.UnicodeFromString(",\n")); + _67_i = (_67_i) + (BigInteger.One); + } + Dafny.ISequence> _73_selfPath; + _73_selfPath = Dafny.Sequence>.FromElements((c).dtor_name); + Dafny.ISequence _74_implBody; + Dafny.IMap>, Dafny.ISequence> _75_traitBodies; + Dafny.ISequence _out22; + Dafny.IMap>, Dafny.ISequence> _out23; + DCOMP.COMP.GenClassImplBody((c).dtor_body, false, DAST.Type.create_Path(Dafny.Sequence>.FromElements(), Dafny.Sequence.FromElements(), DAST.ResolvedType.create_Datatype(_73_selfPath)), _61_typeParamsSet, out _out22, out _out23); + _74_implBody = _out22; + _75_traitBodies = _out23; + _67_i = BigInteger.Zero; + Dafny.ISet> _76_emittedFields; + _76_emittedFields = Dafny.Set>.FromElements(); + while ((_67_i) < (new BigInteger(((c).dtor_ctors).Count))) { + DAST._IDatatypeCtor _77_ctor; + _77_ctor = ((c).dtor_ctors).Select(_67_i); + BigInteger _78_j; + _78_j = BigInteger.Zero; + while ((_78_j) < (new BigInteger(((_77_ctor).dtor_args).Count))) { + DAST._IFormal _79_formal; + _79_formal = ((_77_ctor).dtor_args).Select(_78_j); + if (!((_76_emittedFields).Contains((_79_formal).dtor_name))) { + _76_emittedFields = Dafny.Set>.Union(_76_emittedFields, Dafny.Set>.FromElements((_79_formal).dtor_name)); + Dafny.ISequence _80_formalType; + Dafny.ISequence _out24; + _out24 = DCOMP.COMP.GenType((_79_formal).dtor_typ, false, false); + _80_formalType = _out24; + Dafny.ISequence _81_methodBody; + _81_methodBody = Dafny.Sequence.UnicodeFromString("match self {\n"); + BigInteger _82_k; + _82_k = BigInteger.Zero; + while ((_82_k) < (new BigInteger(((c).dtor_ctors).Count))) { + DAST._IDatatypeCtor _83_ctor2; + _83_ctor2 = ((c).dtor_ctors).Select(_82_k); + Dafny.ISequence _84_ctorMatch; + _84_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), (c).dtor_name), Dafny.Sequence.UnicodeFromString("::")), Dafny.Sequence.UnicodeFromString("r#")), (_83_ctor2).dtor_name), Dafny.Sequence.UnicodeFromString(" { ")); + BigInteger _85_l; + _85_l = BigInteger.Zero; + bool _86_hasMatchingField; + _86_hasMatchingField = false; + while ((_85_l) < (new BigInteger(((_83_ctor2).dtor_args).Count))) { + DAST._IFormal _87_formal2; + _87_formal2 = ((_83_ctor2).dtor_args).Select(_85_l); + if (((_79_formal).dtor_name).Equals((_87_formal2).dtor_name)) { + _86_hasMatchingField = true; } - _81_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_81_ctorMatch, Dafny.Sequence.UnicodeFromString("r#")), (_84_formal2).dtor_name), Dafny.Sequence.UnicodeFromString(", ")); - _82_l = (_82_l) + (BigInteger.One); + _84_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_84_ctorMatch, Dafny.Sequence.UnicodeFromString("r#")), (_87_formal2).dtor_name), Dafny.Sequence.UnicodeFromString(", ")); + _85_l = (_85_l) + (BigInteger.One); } - if (_83_hasMatchingField) { + if (_86_hasMatchingField) { if ((c).dtor_isCo) { - _81_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_81_ctorMatch, Dafny.Sequence.UnicodeFromString("} => ::std::ops::Deref::deref(&")), (_76_formal).dtor_name), Dafny.Sequence.UnicodeFromString(".0),\n")); + _84_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_84_ctorMatch, Dafny.Sequence.UnicodeFromString("} => ::std::ops::Deref::deref(&")), (_79_formal).dtor_name), Dafny.Sequence.UnicodeFromString(".0),\n")); } else { - _81_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_81_ctorMatch, Dafny.Sequence.UnicodeFromString("} => ")), (_76_formal).dtor_name), Dafny.Sequence.UnicodeFromString(",\n")); + _84_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_84_ctorMatch, Dafny.Sequence.UnicodeFromString("} => ")), (_79_formal).dtor_name), Dafny.Sequence.UnicodeFromString(",\n")); } } else { - _81_ctorMatch = Dafny.Sequence.Concat(_81_ctorMatch, Dafny.Sequence.UnicodeFromString("} => panic!(\"field does not exist on this variant\"),\n")); + _84_ctorMatch = Dafny.Sequence.Concat(_84_ctorMatch, Dafny.Sequence.UnicodeFromString("} => panic!(\"field does not exist on this variant\"),\n")); } - _78_methodBody = Dafny.Sequence.Concat(_78_methodBody, _81_ctorMatch); - _79_k = (_79_k) + (BigInteger.One); + _81_methodBody = Dafny.Sequence.Concat(_81_methodBody, _84_ctorMatch); + _82_k = (_82_k) + (BigInteger.One); } - _78_methodBody = Dafny.Sequence.Concat(_78_methodBody, Dafny.Sequence.UnicodeFromString("}\n")); - _71_implBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_71_implBody, Dafny.Sequence.UnicodeFromString("pub fn r#")), (_76_formal).dtor_name), Dafny.Sequence.UnicodeFromString("(&self) -> &")), _77_formalType), Dafny.Sequence.UnicodeFromString(" {\n")), _78_methodBody), Dafny.Sequence.UnicodeFromString("}\n")); + _81_methodBody = Dafny.Sequence.Concat(_81_methodBody, Dafny.Sequence.UnicodeFromString("}\n")); + _74_implBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_74_implBody, Dafny.Sequence.UnicodeFromString("pub fn r#")), (_79_formal).dtor_name), Dafny.Sequence.UnicodeFromString("(&self) -> &")), _80_formalType), Dafny.Sequence.UnicodeFromString(" {\n")), _81_methodBody), Dafny.Sequence.UnicodeFromString("}\n")); } - _75_j = (_75_j) + (BigInteger.One); + _78_j = (_78_j) + (BigInteger.One); } - _64_i = (_64_i) + (BigInteger.One); + _67_i = (_67_i) + (BigInteger.One); } - Dafny.ISequence _85_constrainedTypeParams; - _85_constrainedTypeParams = Dafny.Sequence.UnicodeFromString(""); + Dafny.ISequence _88_constrainedTypeParams; + _88_constrainedTypeParams = Dafny.Sequence.UnicodeFromString(""); if ((new BigInteger(((c).dtor_typeParams).Count)).Sign == 1) { - _60_tpI = BigInteger.Zero; - _85_constrainedTypeParams = Dafny.Sequence.UnicodeFromString("<"); - while ((_60_tpI) < (new BigInteger(((c).dtor_typeParams).Count))) { - if ((_60_tpI).Sign == 1) { - _85_constrainedTypeParams = Dafny.Sequence.Concat(_85_constrainedTypeParams, Dafny.Sequence.UnicodeFromString(", ")); + _63_tpI = BigInteger.Zero; + _88_constrainedTypeParams = Dafny.Sequence.UnicodeFromString("<"); + while ((_63_tpI) < (new BigInteger(((c).dtor_typeParams).Count))) { + if ((_63_tpI).Sign == 1) { + _88_constrainedTypeParams = Dafny.Sequence.Concat(_88_constrainedTypeParams, Dafny.Sequence.UnicodeFromString(", ")); } - DAST._IType _86_tp; - _86_tp = ((c).dtor_typeParams).Select(_60_tpI); - Dafny.ISequence _87_genTp; - Dafny.ISequence _out23; - _out23 = DCOMP.COMP.GenType(_86_tp, false, false); - _87_genTp = _out23; - _85_constrainedTypeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_85_constrainedTypeParams, Dafny.Sequence.UnicodeFromString("r#")), _87_genTp), Dafny.Sequence.UnicodeFromString(": Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static")); - _60_tpI = (_60_tpI) + (BigInteger.One); + DAST._IType _89_tp; + _89_tp = ((c).dtor_typeParams).Select(_63_tpI); + Dafny.ISequence _90_genTp; + Dafny.ISequence _out25; + _out25 = DCOMP.COMP.GenType(_89_tp, false, false); + _90_genTp = _out25; + _88_constrainedTypeParams = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_88_constrainedTypeParams, _90_genTp), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<")), _90_genTp), Dafny.Sequence.UnicodeFromString("> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static")); + _63_tpI = (_63_tpI) + (BigInteger.One); } - _85_constrainedTypeParams = Dafny.Sequence.Concat(_85_constrainedTypeParams, Dafny.Sequence.UnicodeFromString(">")); - } - Dafny.ISequence _88_enumBody; - _88_enumBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("#[derive(PartialEq)]\npub enum r#"), (c).dtor_name), _59_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), _63_ctors), Dafny.Sequence.UnicodeFromString("\n}")), Dafny.Sequence.UnicodeFromString("\n")), Dafny.Sequence.UnicodeFromString("impl ")), _85_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" r#")), (c).dtor_name), _59_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), _71_implBody), Dafny.Sequence.UnicodeFromString("\n}")); - Dafny.ISequence _89_printImpl; - _89_printImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("impl "), _85_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _59_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), Dafny.Sequence.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n")), Dafny.Sequence.UnicodeFromString("match self {\n")); - _64_i = BigInteger.Zero; - while ((_64_i) < (new BigInteger(((c).dtor_ctors).Count))) { - DAST._IDatatypeCtor _90_ctor; - _90_ctor = ((c).dtor_ctors).Select(_64_i); - Dafny.ISequence _91_ctorMatch; - _91_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), (_90_ctor).dtor_name), Dafny.Sequence.UnicodeFromString(" { ")); - Dafny.ISequence _92_modulePrefix; - _92_modulePrefix = (((((c).dtor_enclosingModule)).Equals(Dafny.Sequence.UnicodeFromString("_module"))) ? (Dafny.Sequence.UnicodeFromString("")) : (Dafny.Sequence.Concat(((c).dtor_enclosingModule), Dafny.Sequence.UnicodeFromString(".")))); - Dafny.ISequence _93_printRhs; - _93_printRhs = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("write!(__fmt_print_formatter, \""), _92_modulePrefix), (c).dtor_name), Dafny.Sequence.UnicodeFromString(".")), (_90_ctor).dtor_name), (((_90_ctor).dtor_hasAnyArgs) ? (Dafny.Sequence.UnicodeFromString("(\")?;")) : (Dafny.Sequence.UnicodeFromString("\")?;")))); - BigInteger _94_j; - _94_j = BigInteger.Zero; - while ((_94_j) < (new BigInteger(((_90_ctor).dtor_args).Count))) { - DAST._IFormal _95_formal; - _95_formal = ((_90_ctor).dtor_args).Select(_94_j); - _91_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_91_ctorMatch, (_95_formal).dtor_name), Dafny.Sequence.UnicodeFromString(", ")); - if ((_94_j).Sign == 1) { - _93_printRhs = Dafny.Sequence.Concat(_93_printRhs, Dafny.Sequence.UnicodeFromString("\nwrite!(__fmt_print_formatter, \", \")?;")); + _88_constrainedTypeParams = Dafny.Sequence.Concat(_88_constrainedTypeParams, Dafny.Sequence.UnicodeFromString(">")); + } + Dafny.ISequence _91_enumBody; + _91_enumBody = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("#[derive(PartialEq)]\npub enum r#"), (c).dtor_name), _62_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), _66_ctors), Dafny.Sequence.UnicodeFromString("\n}")), Dafny.Sequence.UnicodeFromString("\n")), Dafny.Sequence.UnicodeFromString("impl ")), _88_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" r#")), (c).dtor_name), _62_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), _74_implBody), Dafny.Sequence.UnicodeFromString("\n}")); + Dafny.ISequence _92_identEraseImpls; + _92_identEraseImpls = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("impl "), _88_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyErasable for r#")), (c).dtor_name), _62_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), Dafny.Sequence.UnicodeFromString("type Erased = Self;\nfn erase(&self) -> &Self::Erased { self }\nfn erase_owned(self) -> Self::Erased { self }}\n")); + _92_identEraseImpls = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_92_identEraseImpls, Dafny.Sequence.UnicodeFromString("impl ")), _88_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable.UnicodeFromString("> for r#")), (c).dtor_name), _62_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), Dafny.Sequence.UnicodeFromString("fn unerase(x: &Self) -> &Self { x }\nfn unerase_owned(x: Self) -> Self { x }}\n")); + Dafny.ISequence _93_printImpl; + _93_printImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("impl "), _88_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _62_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), Dafny.Sequence.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n")), Dafny.Sequence.UnicodeFromString("match self {\n")); + _67_i = BigInteger.Zero; + while ((_67_i) < (new BigInteger(((c).dtor_ctors).Count))) { + DAST._IDatatypeCtor _94_ctor; + _94_ctor = ((c).dtor_ctors).Select(_67_i); + Dafny.ISequence _95_ctorMatch; + _95_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), (_94_ctor).dtor_name), Dafny.Sequence.UnicodeFromString(" { ")); + Dafny.ISequence _96_modulePrefix; + _96_modulePrefix = (((((c).dtor_enclosingModule)).Equals(Dafny.Sequence.UnicodeFromString("_module"))) ? (Dafny.Sequence.UnicodeFromString("")) : (Dafny.Sequence.Concat(((c).dtor_enclosingModule), Dafny.Sequence.UnicodeFromString(".")))); + Dafny.ISequence _97_printRhs; + _97_printRhs = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("write!(__fmt_print_formatter, \""), _96_modulePrefix), (c).dtor_name), Dafny.Sequence.UnicodeFromString(".")), (_94_ctor).dtor_name), (((_94_ctor).dtor_hasAnyArgs) ? (Dafny.Sequence.UnicodeFromString("(\")?;")) : (Dafny.Sequence.UnicodeFromString("\")?;")))); + BigInteger _98_j; + _98_j = BigInteger.Zero; + while ((_98_j) < (new BigInteger(((_94_ctor).dtor_args).Count))) { + DAST._IFormal _99_formal; + _99_formal = ((_94_ctor).dtor_args).Select(_98_j); + _95_ctorMatch = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_95_ctorMatch, (_99_formal).dtor_name), Dafny.Sequence.UnicodeFromString(", ")); + if ((_98_j).Sign == 1) { + _97_printRhs = Dafny.Sequence.Concat(_97_printRhs, Dafny.Sequence.UnicodeFromString("\nwrite!(__fmt_print_formatter, \", \")?;")); } - _93_printRhs = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_93_printRhs, Dafny.Sequence.UnicodeFromString("\n::dafny_runtime::DafnyPrint::fmt_print(")), (_95_formal).dtor_name), Dafny.Sequence.UnicodeFromString(", __fmt_print_formatter, false)?;")); - _94_j = (_94_j) + (BigInteger.One); + _97_printRhs = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_97_printRhs, Dafny.Sequence.UnicodeFromString("\n::dafny_runtime::DafnyPrint::fmt_print(")), (_99_formal).dtor_name), Dafny.Sequence.UnicodeFromString(", __fmt_print_formatter, false)?;")); + _98_j = (_98_j) + (BigInteger.One); } - _91_ctorMatch = Dafny.Sequence.Concat(_91_ctorMatch, Dafny.Sequence.UnicodeFromString("}")); - if ((_90_ctor).dtor_hasAnyArgs) { - _93_printRhs = Dafny.Sequence.Concat(_93_printRhs, Dafny.Sequence.UnicodeFromString("\nwrite!(__fmt_print_formatter, \")\")?;")); + _95_ctorMatch = Dafny.Sequence.Concat(_95_ctorMatch, Dafny.Sequence.UnicodeFromString("}")); + if ((_94_ctor).dtor_hasAnyArgs) { + _97_printRhs = Dafny.Sequence.Concat(_97_printRhs, Dafny.Sequence.UnicodeFromString("\nwrite!(__fmt_print_formatter, \")\")?;")); } - _93_printRhs = Dafny.Sequence.Concat(_93_printRhs, Dafny.Sequence.UnicodeFromString("\nOk(())")); - _89_printImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_89_printImpl, Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("::")), _91_ctorMatch), Dafny.Sequence.UnicodeFromString(" => {\n")), _93_printRhs), Dafny.Sequence.UnicodeFromString("\n}\n")); - _64_i = (_64_i) + (BigInteger.One); + _97_printRhs = Dafny.Sequence.Concat(_97_printRhs, Dafny.Sequence.UnicodeFromString("\nOk(())")); + _93_printImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_93_printImpl, Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("::")), _95_ctorMatch), Dafny.Sequence.UnicodeFromString(" => {\n")), _97_printRhs), Dafny.Sequence.UnicodeFromString("\n}\n")); + _67_i = (_67_i) + (BigInteger.One); } - _89_printImpl = Dafny.Sequence.Concat(_89_printImpl, Dafny.Sequence.UnicodeFromString("}\n}\n}\n")); - Dafny.ISequence _96_defaultImpl; - _96_defaultImpl = Dafny.Sequence.UnicodeFromString(""); + _93_printImpl = Dafny.Sequence.Concat(_93_printImpl, Dafny.Sequence.UnicodeFromString("}\n}\n}\n")); + Dafny.ISequence _100_defaultImpl; + _100_defaultImpl = Dafny.Sequence.UnicodeFromString(""); if ((new BigInteger(((c).dtor_ctors).Count)).Sign == 1) { - _96_defaultImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("impl "), _85_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _59_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), Dafny.Sequence.UnicodeFromString("fn default() -> Self {\n")), Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("::r#")), (((c).dtor_ctors).Select(BigInteger.Zero)).dtor_name), Dafny.Sequence.UnicodeFromString(" {\n")); - _64_i = BigInteger.Zero; - while ((_64_i) < (new BigInteger(((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Count))) { - DAST._IFormal _97_formal; - _97_formal = ((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Select(_64_i); - _96_defaultImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_96_defaultImpl, (_97_formal).dtor_name), Dafny.Sequence.UnicodeFromString(": std::default::Default::default(),\n")); - _64_i = (_64_i) + (BigInteger.One); + _100_defaultImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("impl "), _88_constrainedTypeParams), Dafny.Sequence.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _62_typeParams), Dafny.Sequence.UnicodeFromString(" {\n")), Dafny.Sequence.UnicodeFromString("fn default() -> Self {\n")), Dafny.Sequence.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence.UnicodeFromString("::r#")), (((c).dtor_ctors).Select(BigInteger.Zero)).dtor_name), Dafny.Sequence.UnicodeFromString(" {\n")); + _67_i = BigInteger.Zero; + while ((_67_i) < (new BigInteger(((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Count))) { + DAST._IFormal _101_formal; + _101_formal = ((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Select(_67_i); + _100_defaultImpl = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_100_defaultImpl, (_101_formal).dtor_name), Dafny.Sequence.UnicodeFromString(": std::default::Default::default(),\n")); + _67_i = (_67_i) + (BigInteger.One); } - _96_defaultImpl = Dafny.Sequence.Concat(_96_defaultImpl, Dafny.Sequence.UnicodeFromString("}\n}\n}\n")); + _100_defaultImpl = Dafny.Sequence.Concat(_100_defaultImpl, Dafny.Sequence.UnicodeFromString("}\n}\n}\n")); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_88_enumBody, Dafny.Sequence.UnicodeFromString("\n")), _89_printImpl), Dafny.Sequence.UnicodeFromString("\n")), _96_defaultImpl); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_91_enumBody, Dafny.Sequence.UnicodeFromString("\n")), _92_identEraseImpls), Dafny.Sequence.UnicodeFromString("\n")), _93_printImpl), Dafny.Sequence.UnicodeFromString("\n")), _100_defaultImpl); return s; } public static Dafny.ISequence GenPath(Dafny.ISequence> p) { @@ -4212,14 +4307,14 @@ public COMP() { return s; } else { s = Dafny.Sequence.UnicodeFromString("super::"); - BigInteger _98_i; - _98_i = BigInteger.Zero; - while ((_98_i) < (new BigInteger((p).Count))) { - if ((_98_i).Sign == 1) { + BigInteger _102_i; + _102_i = BigInteger.Zero; + while ((_102_i) < (new BigInteger((p).Count))) { + if ((_102_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("::")); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), ((p).Select(_98_i))); - _98_i = (_98_i) + (BigInteger.One); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), ((p).Select(_102_i))); + _102_i = (_102_i) + (BigInteger.One); } } return s; @@ -4229,18 +4324,18 @@ public COMP() { s = Dafny.Sequence.UnicodeFromString(""); if ((new BigInteger((args).Count)).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("<")); - BigInteger _99_i; - _99_i = BigInteger.Zero; - while ((_99_i) < (new BigInteger((args).Count))) { - if ((_99_i).Sign == 1) { + BigInteger _103_i; + _103_i = BigInteger.Zero; + while ((_103_i) < (new BigInteger((args).Count))) { + if ((_103_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _100_genTp; - Dafny.ISequence _out24; - _out24 = DCOMP.COMP.GenType((args).Select(_99_i), inBinding, inFn); - _100_genTp = _out24; - s = Dafny.Sequence.Concat(s, _100_genTp); - _99_i = (_99_i) + (BigInteger.One); + Dafny.ISequence _104_genTp; + Dafny.ISequence _out26; + _out26 = DCOMP.COMP.GenType((args).Select(_103_i), inBinding, inFn); + _104_genTp = _out26; + s = Dafny.Sequence.Concat(s, _104_genTp); + _103_i = (_103_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(">")); } @@ -4250,29 +4345,29 @@ public COMP() { Dafny.ISequence s = Dafny.Sequence.Empty; DAST._IType _source4 = c; if (_source4.is_Path) { - Dafny.ISequence> _101___mcc_h0 = _source4.dtor_Path_a0; - Dafny.ISequence _102___mcc_h1 = _source4.dtor_typeArgs; - DAST._IResolvedType _103___mcc_h2 = _source4.dtor_resolved; - DAST._IResolvedType _104_resolved = _103___mcc_h2; - Dafny.ISequence _105_args = _102___mcc_h1; - Dafny.ISequence> _106_p = _101___mcc_h0; + Dafny.ISequence> _105___mcc_h0 = _source4.dtor_Path_a0; + Dafny.ISequence _106___mcc_h1 = _source4.dtor_typeArgs; + DAST._IResolvedType _107___mcc_h2 = _source4.dtor_resolved; + DAST._IResolvedType _108_resolved = _107___mcc_h2; + Dafny.ISequence _109_args = _106___mcc_h1; + Dafny.ISequence> _110_p = _105___mcc_h0; { - Dafny.ISequence _out25; - _out25 = DCOMP.COMP.GenPath(_106_p); - s = _out25; - Dafny.ISequence _107_typeArgs; - Dafny.ISequence _out26; - _out26 = DCOMP.COMP.GenTypeArgs(_105_args, inBinding, inFn); - _107_typeArgs = _out26; - s = Dafny.Sequence.Concat(s, _107_typeArgs); - DAST._IResolvedType _source5 = _104_resolved; + Dafny.ISequence _out27; + _out27 = DCOMP.COMP.GenPath(_110_p); + s = _out27; + Dafny.ISequence _111_typeArgs; + Dafny.ISequence _out28; + _out28 = DCOMP.COMP.GenTypeArgs(_109_args, inBinding, inFn); + _111_typeArgs = _out28; + s = Dafny.Sequence.Concat(s, _111_typeArgs); + DAST._IResolvedType _source5 = _108_resolved; if (_source5.is_Datatype) { - Dafny.ISequence> _108___mcc_h16 = _source5.dtor_path; + Dafny.ISequence> _112___mcc_h16 = _source5.dtor_path; { s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::rc::Rc<"), s), Dafny.Sequence.UnicodeFromString(">")); } } else if (_source5.is_Trait) { - Dafny.ISequence> _109___mcc_h18 = _source5.dtor_path; + Dafny.ISequence> _113___mcc_h18 = _source5.dtor_path; { if (inBinding) { s = Dafny.Sequence.UnicodeFromString("_"); @@ -4281,128 +4376,128 @@ public COMP() { } } } else { - DAST._IResolvedType _110_Primitive = _104_resolved; + DAST._IResolvedType _114_Primitive = _108_resolved; } } } else if (_source4.is_Tuple) { - Dafny.ISequence _111___mcc_h3 = _source4.dtor_Tuple_a0; - Dafny.ISequence _112_types = _111___mcc_h3; + Dafny.ISequence _115___mcc_h3 = _source4.dtor_Tuple_a0; + Dafny.ISequence _116_types = _115___mcc_h3; { s = Dafny.Sequence.UnicodeFromString("("); - BigInteger _113_i; - _113_i = BigInteger.Zero; - while ((_113_i) < (new BigInteger((_112_types).Count))) { - if ((_113_i).Sign == 1) { + BigInteger _117_i; + _117_i = BigInteger.Zero; + while ((_117_i) < (new BigInteger((_116_types).Count))) { + if ((_117_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" ")); } - Dafny.ISequence _114_generated; - Dafny.ISequence _out27; - _out27 = DCOMP.COMP.GenType((_112_types).Select(_113_i), inBinding, inFn); - _114_generated = _out27; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, _114_generated), Dafny.Sequence.UnicodeFromString(",")); - _113_i = (_113_i) + (BigInteger.One); + Dafny.ISequence _118_generated; + Dafny.ISequence _out29; + _out29 = DCOMP.COMP.GenType((_116_types).Select(_117_i), inBinding, inFn); + _118_generated = _out29; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, _118_generated), Dafny.Sequence.UnicodeFromString(",")); + _117_i = (_117_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(")")); } } else if (_source4.is_Array) { - DAST._IType _115___mcc_h4 = _source4.dtor_element; - DAST._IType _116_element = _115___mcc_h4; + DAST._IType _119___mcc_h4 = _source4.dtor_element; + DAST._IType _120_element = _119___mcc_h4; { - Dafny.ISequence _117_elemStr; - Dafny.ISequence _out28; - _out28 = DCOMP.COMP.GenType(_116_element, inBinding, inFn); - _117_elemStr = _out28; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::vec::Vec<"), _117_elemStr), Dafny.Sequence.UnicodeFromString(">")); + Dafny.ISequence _121_elemStr; + Dafny.ISequence _out30; + _out30 = DCOMP.COMP.GenType(_120_element, inBinding, inFn); + _121_elemStr = _out30; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::vec::Vec<"), _121_elemStr), Dafny.Sequence.UnicodeFromString(">")); } } else if (_source4.is_Seq) { - DAST._IType _118___mcc_h5 = _source4.dtor_element; - DAST._IType _119_element = _118___mcc_h5; + DAST._IType _122___mcc_h5 = _source4.dtor_element; + DAST._IType _123_element = _122___mcc_h5; { - Dafny.ISequence _120_elemStr; - Dafny.ISequence _out29; - _out29 = DCOMP.COMP.GenType(_119_element, inBinding, inFn); - _120_elemStr = _out29; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::vec::Vec<"), _120_elemStr), Dafny.Sequence.UnicodeFromString(">")); + Dafny.ISequence _124_elemStr; + Dafny.ISequence _out31; + _out31 = DCOMP.COMP.GenType(_123_element, inBinding, inFn); + _124_elemStr = _out31; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::vec::Vec<"), _124_elemStr), Dafny.Sequence.UnicodeFromString(">")); } } else if (_source4.is_Set) { - DAST._IType _121___mcc_h6 = _source4.dtor_element; - DAST._IType _122_element = _121___mcc_h6; + DAST._IType _125___mcc_h6 = _source4.dtor_element; + DAST._IType _126_element = _125___mcc_h6; { - Dafny.ISequence _123_elemStr; - Dafny.ISequence _out30; - _out30 = DCOMP.COMP.GenType(_122_element, inBinding, inFn); - _123_elemStr = _out30; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::collections::HashSet<"), _123_elemStr), Dafny.Sequence.UnicodeFromString(">")); + Dafny.ISequence _127_elemStr; + Dafny.ISequence _out32; + _out32 = DCOMP.COMP.GenType(_126_element, inBinding, inFn); + _127_elemStr = _out32; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::collections::HashSet<"), _127_elemStr), Dafny.Sequence.UnicodeFromString(">")); } } else if (_source4.is_Multiset) { - DAST._IType _124___mcc_h7 = _source4.dtor_element; - DAST._IType _125_element = _124___mcc_h7; + DAST._IType _128___mcc_h7 = _source4.dtor_element; + DAST._IType _129_element = _128___mcc_h7; { - Dafny.ISequence _126_elemStr; - Dafny.ISequence _out31; - _out31 = DCOMP.COMP.GenType(_125_element, inBinding, inFn); - _126_elemStr = _out31; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::collections::HashMap<"), _126_elemStr), Dafny.Sequence.UnicodeFromString(", u64>")); + Dafny.ISequence _130_elemStr; + Dafny.ISequence _out33; + _out33 = DCOMP.COMP.GenType(_129_element, inBinding, inFn); + _130_elemStr = _out33; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::collections::HashMap<"), _130_elemStr), Dafny.Sequence.UnicodeFromString(", u64>")); } } else if (_source4.is_Map) { - DAST._IType _127___mcc_h8 = _source4.dtor_key; - DAST._IType _128___mcc_h9 = _source4.dtor_value; - DAST._IType _129_value = _128___mcc_h9; - DAST._IType _130_key = _127___mcc_h8; + DAST._IType _131___mcc_h8 = _source4.dtor_key; + DAST._IType _132___mcc_h9 = _source4.dtor_value; + DAST._IType _133_value = _132___mcc_h9; + DAST._IType _134_key = _131___mcc_h8; { - Dafny.ISequence _131_keyStr; - Dafny.ISequence _out32; - _out32 = DCOMP.COMP.GenType(_130_key, inBinding, inFn); - _131_keyStr = _out32; - Dafny.ISequence _132_valueStr; - Dafny.ISequence _out33; - _out33 = DCOMP.COMP.GenType(_129_value, inBinding, inFn); - _132_valueStr = _out33; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::collections::HashMap<"), _131_keyStr), Dafny.Sequence.UnicodeFromString(", ")), _132_valueStr), Dafny.Sequence.UnicodeFromString(">")); + Dafny.ISequence _135_keyStr; + Dafny.ISequence _out34; + _out34 = DCOMP.COMP.GenType(_134_key, inBinding, inFn); + _135_keyStr = _out34; + Dafny.ISequence _136_valueStr; + Dafny.ISequence _out35; + _out35 = DCOMP.COMP.GenType(_133_value, inBinding, inFn); + _136_valueStr = _out35; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::collections::HashMap<"), _135_keyStr), Dafny.Sequence.UnicodeFromString(", ")), _136_valueStr), Dafny.Sequence.UnicodeFromString(">")); } } else if (_source4.is_Arrow) { - Dafny.ISequence _133___mcc_h10 = _source4.dtor_args; - DAST._IType _134___mcc_h11 = _source4.dtor_result; - DAST._IType _135_result = _134___mcc_h11; - Dafny.ISequence _136_args = _133___mcc_h10; + Dafny.ISequence _137___mcc_h10 = _source4.dtor_args; + DAST._IType _138___mcc_h11 = _source4.dtor_result; + DAST._IType _139_result = _138___mcc_h11; + Dafny.ISequence _140_args = _137___mcc_h10; { if (inBinding) { s = Dafny.Sequence.UnicodeFromString("::dafny_runtime::FunctionWrapper<_>"); } else { if (inFn) { - s = Dafny.Sequence.UnicodeFromString("::dafny_runtime::FunctionWrapper.UnicodeFromString("::dafny_runtime::FunctionWrapper<::std::boxed::Box.UnicodeFromString("::dafny_runtime::FunctionWrapper.UnicodeFromString("::dafny_runtime::FunctionWrapper.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _138_generated; - Dafny.ISequence _out34; - _out34 = DCOMP.COMP.GenType((_136_args).Select(_137_i), inBinding, true); - _138_generated = _out34; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("&")), _138_generated); - _137_i = (_137_i) + (BigInteger.One); + Dafny.ISequence _142_generated; + Dafny.ISequence _out36; + _out36 = DCOMP.COMP.GenType((_140_args).Select(_141_i), inBinding, true); + _142_generated = _out36; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("&")), _142_generated); + _141_i = (_141_i) + (BigInteger.One); } - Dafny.ISequence _139_resultType; - Dafny.ISequence _out35; - _out35 = DCOMP.COMP.GenType(_135_result, inBinding, inFn); - _139_resultType = _out35; + Dafny.ISequence _143_resultType; + Dafny.ISequence _out37; + _out37 = DCOMP.COMP.GenType(_139_result, inBinding, inFn); + _143_resultType = _out37; if (inFn) { - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(") -> ")), _139_resultType), Dafny.Sequence.UnicodeFromString(" + 'static>>")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(") -> ")), _143_resultType), Dafny.Sequence.UnicodeFromString(" + 'static>>")); } else { - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(") -> ")), _139_resultType), Dafny.Sequence.UnicodeFromString(" + Clone + 'static>")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(") -> ")), _143_resultType), Dafny.Sequence.UnicodeFromString(" + Clone + 'static>")); } } } } else if (_source4.is_Primitive) { - DAST._IPrimitive _140___mcc_h12 = _source4.dtor_Primitive_a0; - DAST._IPrimitive _141_p = _140___mcc_h12; + DAST._IPrimitive _144___mcc_h12 = _source4.dtor_Primitive_a0; + DAST._IPrimitive _145_p = _144___mcc_h12; { - DAST._IPrimitive _source6 = _141_p; + DAST._IPrimitive _source6 = _145_p; if (_source6.is_String) { s = Dafny.Sequence.UnicodeFromString("Vec"); } else if (_source6.is_Bool) { @@ -4412,15 +4507,15 @@ public COMP() { } } } else if (_source4.is_Passthrough) { - Dafny.ISequence _142___mcc_h13 = _source4.dtor_Passthrough_a0; - Dafny.ISequence _143_v = _142___mcc_h13; - s = _143_v; + Dafny.ISequence _146___mcc_h13 = _source4.dtor_Passthrough_a0; + Dafny.ISequence _147_v = _146___mcc_h13; + s = _147_v; } else { - Dafny.ISequence _144___mcc_h14 = _source4.dtor_TypeArg_a0; - Dafny.ISequence _source7 = _144___mcc_h14; - Dafny.ISequence _145___mcc_h15 = _source7; - Dafny.ISequence _146_name = _145___mcc_h15; - s = _146_name; + Dafny.ISequence _148___mcc_h14 = _source4.dtor_TypeArg_a0; + Dafny.ISequence _source7 = _148___mcc_h14; + Dafny.ISequence _149___mcc_h15 = _source7; + Dafny.ISequence _150_name = _149___mcc_h15; + s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), _150_name); } return s; } @@ -4429,603 +4524,650 @@ public static void GenClassImplBody(Dafny.ISequence body, bool traitBodies = Dafny.Map>, Dafny.ISequence>.Empty; s = Dafny.Sequence.UnicodeFromString(""); traitBodies = Dafny.Map>, Dafny.ISequence>.FromElements(); - BigInteger _147_i; - _147_i = BigInteger.Zero; - while ((_147_i) < (new BigInteger((body).Count))) { - DAST._IClassItem _source8 = (body).Select(_147_i); + BigInteger _151_i; + _151_i = BigInteger.Zero; + while ((_151_i) < (new BigInteger((body).Count))) { + DAST._IClassItem _source8 = (body).Select(_151_i); if (_source8.is_Method) { - DAST._IMethod _148___mcc_h0 = _source8.dtor_Method_a0; - DAST._IMethod _149_m = _148___mcc_h0; + DAST._IMethod _152___mcc_h0 = _source8.dtor_Method_a0; + DAST._IMethod _153_m = _152___mcc_h0; { - DAST._IOptional>> _source9 = (_149_m).dtor_overridingPath; + DAST._IOptional>> _source9 = (_153_m).dtor_overridingPath; if (_source9.is_Some) { - Dafny.ISequence> _150___mcc_h2 = _source9.dtor_Some_a0; - Dafny.ISequence> _151_p = _150___mcc_h2; + Dafny.ISequence> _154___mcc_h2 = _source9.dtor_Some_a0; + Dafny.ISequence> _155_p = _154___mcc_h2; { - Dafny.ISequence _152_existing; - _152_existing = Dafny.Sequence.UnicodeFromString(""); - if ((traitBodies).Contains(_151_p)) { - _152_existing = Dafny.Map>, Dafny.ISequence>.Select(traitBodies, _151_p); + Dafny.ISequence _156_existing; + _156_existing = Dafny.Sequence.UnicodeFromString(""); + if ((traitBodies).Contains(_155_p)) { + _156_existing = Dafny.Map>, Dafny.ISequence>.Select(traitBodies, _155_p); } - if ((new BigInteger((_152_existing).Count)).Sign == 1) { - _152_existing = Dafny.Sequence.Concat(_152_existing, Dafny.Sequence.UnicodeFromString("\n")); + if ((new BigInteger((_156_existing).Count)).Sign == 1) { + _156_existing = Dafny.Sequence.Concat(_156_existing, Dafny.Sequence.UnicodeFromString("\n")); } - Dafny.ISequence _153_genMethod; - Dafny.ISequence _out36; - _out36 = DCOMP.COMP.GenMethod(_149_m, true, enclosingType, enclosingTypeParams); - _153_genMethod = _out36; - _152_existing = Dafny.Sequence.Concat(_152_existing, _153_genMethod); - traitBodies = Dafny.Map>, Dafny.ISequence>.Merge(traitBodies, Dafny.Map>, Dafny.ISequence>.FromElements(new Dafny.Pair>, Dafny.ISequence>(_151_p, _152_existing))); + Dafny.ISequence _157_genMethod; + Dafny.ISequence _out38; + _out38 = DCOMP.COMP.GenMethod(_153_m, true, enclosingType, enclosingTypeParams); + _157_genMethod = _out38; + _156_existing = Dafny.Sequence.Concat(_156_existing, _157_genMethod); + traitBodies = Dafny.Map>, Dafny.ISequence>.Merge(traitBodies, Dafny.Map>, Dafny.ISequence>.FromElements(new Dafny.Pair>, Dafny.ISequence>(_155_p, _156_existing))); } } else { { - Dafny.ISequence _154_generated; - Dafny.ISequence _out37; - _out37 = DCOMP.COMP.GenMethod(_149_m, forTrait, enclosingType, enclosingTypeParams); - _154_generated = _out37; - s = Dafny.Sequence.Concat(s, _154_generated); + Dafny.ISequence _158_generated; + Dafny.ISequence _out39; + _out39 = DCOMP.COMP.GenMethod(_153_m, forTrait, enclosingType, enclosingTypeParams); + _158_generated = _out39; + s = Dafny.Sequence.Concat(s, _158_generated); } } } } else { - DAST._IFormal _155___mcc_h1 = _source8.dtor_Field_a0; - DAST._IFormal _156_f = _155___mcc_h1; + DAST._IFormal _159___mcc_h1 = _source8.dtor_Field_a0; + DAST._IFormal _160_f = _159___mcc_h1; } if ((new BigInteger((s).Count)).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("\n")); } - _147_i = (_147_i) + (BigInteger.One); + _151_i = (_151_i) + (BigInteger.One); } } public static Dafny.ISequence GenParams(Dafny.ISequence @params) { Dafny.ISequence s = Dafny.Sequence.Empty; s = Dafny.Sequence.UnicodeFromString(""); - BigInteger _157_i; - _157_i = BigInteger.Zero; - while ((_157_i) < (new BigInteger((@params).Count))) { - DAST._IFormal _158_param; - _158_param = (@params).Select(_157_i); - Dafny.ISequence _159_paramType; - Dafny.ISequence _out38; - _out38 = DCOMP.COMP.GenType((_158_param).dtor_typ, false, false); - _159_paramType = _out38; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), (_158_param).dtor_name), Dafny.Sequence.UnicodeFromString(": &")), _159_paramType); - if ((_157_i) < ((new BigInteger((@params).Count)) - (BigInteger.One))) { + BigInteger _161_i; + _161_i = BigInteger.Zero; + while ((_161_i) < (new BigInteger((@params).Count))) { + DAST._IFormal _162_param; + _162_param = (@params).Select(_161_i); + Dafny.ISequence _163_paramType; + Dafny.ISequence _out40; + _out40 = DCOMP.COMP.GenType((_162_param).dtor_typ, false, false); + _163_paramType = _out40; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), (_162_param).dtor_name), Dafny.Sequence.UnicodeFromString(": &")), _163_paramType); + if ((_161_i) < ((new BigInteger((@params).Count)) - (BigInteger.One))) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - _157_i = (_157_i) + (BigInteger.One); + _161_i = (_161_i) + (BigInteger.One); } return s; } public static Dafny.ISequence GenMethod(DAST._IMethod m, bool forTrait, DAST._IType enclosingType, Dafny.ISet enclosingTypeParams) { Dafny.ISequence s = Dafny.Sequence.Empty; - Dafny.ISequence _160_params; - Dafny.ISequence _out39; - _out39 = DCOMP.COMP.GenParams((m).dtor_params); - _160_params = _out39; - Dafny.ISequence> _161_paramNames; - _161_paramNames = Dafny.Sequence>.FromElements(); - BigInteger _162_paramI; - _162_paramI = BigInteger.Zero; - while ((_162_paramI) < (new BigInteger(((m).dtor_params).Count))) { - _161_paramNames = Dafny.Sequence>.Concat(_161_paramNames, Dafny.Sequence>.FromElements((((m).dtor_params).Select(_162_paramI)).dtor_name)); - _162_paramI = (_162_paramI) + (BigInteger.One); + Dafny.ISequence _164_params; + Dafny.ISequence _out41; + _out41 = DCOMP.COMP.GenParams((m).dtor_params); + _164_params = _out41; + Dafny.ISequence> _165_paramNames; + _165_paramNames = Dafny.Sequence>.FromElements(); + BigInteger _166_paramI; + _166_paramI = BigInteger.Zero; + while ((_166_paramI) < (new BigInteger(((m).dtor_params).Count))) { + _165_paramNames = Dafny.Sequence>.Concat(_165_paramNames, Dafny.Sequence>.FromElements((((m).dtor_params).Select(_166_paramI)).dtor_name)); + _166_paramI = (_166_paramI) + (BigInteger.One); } if (!((m).dtor_isStatic)) { if (forTrait) { - _160_params = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("&self"), Dafny.Sequence.UnicodeFromString(", ")), _160_params); + _164_params = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("&self"), Dafny.Sequence.UnicodeFromString(", ")), _164_params); } else { - Dafny.ISequence _163_enclosingTypeString; - Dafny.ISequence _out40; - _out40 = DCOMP.COMP.GenType(enclosingType, false, false); - _163_enclosingTypeString = _out40; - _160_params = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("self: &"), _163_enclosingTypeString), Dafny.Sequence.UnicodeFromString(", ")), _160_params); + Dafny.ISequence _167_enclosingTypeString; + Dafny.ISequence _out42; + _out42 = DCOMP.COMP.GenType(enclosingType, false, false); + _167_enclosingTypeString = _out42; + _164_params = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("self: &"), _167_enclosingTypeString), Dafny.Sequence.UnicodeFromString(", ")), _164_params); } } - Dafny.ISequence _164_retType; - _164_retType = (((new BigInteger(((m).dtor_outTypes).Count)) != (BigInteger.One)) ? (Dafny.Sequence.UnicodeFromString("(")) : (Dafny.Sequence.UnicodeFromString(""))); - BigInteger _165_typeI; - _165_typeI = BigInteger.Zero; - while ((_165_typeI) < (new BigInteger(((m).dtor_outTypes).Count))) { - if ((_165_typeI).Sign == 1) { - _164_retType = Dafny.Sequence.Concat(_164_retType, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _168_retType; + _168_retType = (((new BigInteger(((m).dtor_outTypes).Count)) != (BigInteger.One)) ? (Dafny.Sequence.UnicodeFromString("(")) : (Dafny.Sequence.UnicodeFromString(""))); + BigInteger _169_typeI; + _169_typeI = BigInteger.Zero; + while ((_169_typeI) < (new BigInteger(((m).dtor_outTypes).Count))) { + if ((_169_typeI).Sign == 1) { + _168_retType = Dafny.Sequence.Concat(_168_retType, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _166_typeString; - Dafny.ISequence _out41; - _out41 = DCOMP.COMP.GenType(((m).dtor_outTypes).Select(_165_typeI), false, false); - _166_typeString = _out41; - _164_retType = Dafny.Sequence.Concat(_164_retType, _166_typeString); - _165_typeI = (_165_typeI) + (BigInteger.One); + Dafny.ISequence _170_typeString; + Dafny.ISequence _out43; + _out43 = DCOMP.COMP.GenType(((m).dtor_outTypes).Select(_169_typeI), false, false); + _170_typeString = _out43; + _168_retType = Dafny.Sequence.Concat(_168_retType, _170_typeString); + _169_typeI = (_169_typeI) + (BigInteger.One); } if ((new BigInteger(((m).dtor_outTypes).Count)) != (BigInteger.One)) { - _164_retType = Dafny.Sequence.Concat(_164_retType, Dafny.Sequence.UnicodeFromString(")")); + _168_retType = Dafny.Sequence.Concat(_168_retType, Dafny.Sequence.UnicodeFromString(")")); } if (forTrait) { s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("fn r#"), (m).dtor_name); } else { s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("pub fn r#"), (m).dtor_name); } - Dafny.ISequence _167_typeParamsFiltered; - _167_typeParamsFiltered = Dafny.Sequence.FromElements(); - BigInteger _168_typeParamI; - _168_typeParamI = BigInteger.Zero; - while ((_168_typeParamI) < (new BigInteger(((m).dtor_typeParams).Count))) { - DAST._IType _169_typeParam; - _169_typeParam = ((m).dtor_typeParams).Select(_168_typeParamI); - if (!((enclosingTypeParams).Contains(_169_typeParam))) { - _167_typeParamsFiltered = Dafny.Sequence.Concat(_167_typeParamsFiltered, Dafny.Sequence.FromElements(_169_typeParam)); + Dafny.ISequence _171_typeParamsFiltered; + _171_typeParamsFiltered = Dafny.Sequence.FromElements(); + BigInteger _172_typeParamI; + _172_typeParamI = BigInteger.Zero; + while ((_172_typeParamI) < (new BigInteger(((m).dtor_typeParams).Count))) { + DAST._IType _173_typeParam; + _173_typeParam = ((m).dtor_typeParams).Select(_172_typeParamI); + if (!((enclosingTypeParams).Contains(_173_typeParam))) { + _171_typeParamsFiltered = Dafny.Sequence.Concat(_171_typeParamsFiltered, Dafny.Sequence.FromElements(_173_typeParam)); } - _168_typeParamI = (_168_typeParamI) + (BigInteger.One); + _172_typeParamI = (_172_typeParamI) + (BigInteger.One); } - if ((new BigInteger((_167_typeParamsFiltered).Count)).Sign == 1) { + if ((new BigInteger((_171_typeParamsFiltered).Count)).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("<")); - BigInteger _170_i; - _170_i = BigInteger.Zero; - while ((_170_i) < (new BigInteger((_167_typeParamsFiltered).Count))) { - if ((_170_i).Sign == 1) { + BigInteger _174_i; + _174_i = BigInteger.Zero; + while ((_174_i) < (new BigInteger((_171_typeParamsFiltered).Count))) { + if ((_174_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _171_typeString; - Dafny.ISequence _out42; - _out42 = DCOMP.COMP.GenType((_167_typeParamsFiltered).Select(_170_i), false, false); - _171_typeString = _out42; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, _171_typeString), Dafny.Sequence.UnicodeFromString(": Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static")); - _170_i = (_170_i) + (BigInteger.One); + Dafny.ISequence _175_typeString; + Dafny.ISequence _out44; + _out44 = DCOMP.COMP.GenType((_171_typeParamsFiltered).Select(_174_i), false, false); + _175_typeString = _out44; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, _175_typeString), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<")), _175_typeString), Dafny.Sequence.UnicodeFromString("> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static")); + _174_i = (_174_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(">")); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("(")), _160_params), Dafny.Sequence.UnicodeFromString(") -> ")), _164_retType); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("(")), _164_params), Dafny.Sequence.UnicodeFromString(") -> ")), _168_retType); if ((m).dtor_hasBody) { - Dafny.ISequence _172_earlyReturn; - _172_earlyReturn = Dafny.Sequence.UnicodeFromString("return;"); + Dafny.ISequence _176_earlyReturn; + _176_earlyReturn = Dafny.Sequence.UnicodeFromString("return;"); DAST._IOptional>> _source10 = (m).dtor_outVars; if (_source10.is_Some) { - Dafny.ISequence> _173___mcc_h0 = _source10.dtor_Some_a0; - Dafny.ISequence> _174_outVars = _173___mcc_h0; + Dafny.ISequence> _177___mcc_h0 = _source10.dtor_Some_a0; + Dafny.ISequence> _178_outVars = _177___mcc_h0; { - _172_earlyReturn = Dafny.Sequence.UnicodeFromString("return ("); - BigInteger _175_outI; - _175_outI = BigInteger.Zero; - while ((_175_outI) < (new BigInteger((_174_outVars).Count))) { - if ((_175_outI).Sign == 1) { - _172_earlyReturn = Dafny.Sequence.Concat(_172_earlyReturn, Dafny.Sequence.UnicodeFromString(", ")); + _176_earlyReturn = Dafny.Sequence.UnicodeFromString("return ("); + BigInteger _179_outI; + _179_outI = BigInteger.Zero; + while ((_179_outI) < (new BigInteger((_178_outVars).Count))) { + if ((_179_outI).Sign == 1) { + _176_earlyReturn = Dafny.Sequence.Concat(_176_earlyReturn, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _176_outVar; - _176_outVar = (_174_outVars).Select(_175_outI); - _172_earlyReturn = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_172_earlyReturn, Dafny.Sequence.UnicodeFromString("r#")), (_176_outVar)); - _175_outI = (_175_outI) + (BigInteger.One); + Dafny.ISequence _180_outVar; + _180_outVar = (_178_outVars).Select(_179_outI); + _176_earlyReturn = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_176_earlyReturn, Dafny.Sequence.UnicodeFromString("r#")), (_180_outVar)); + _179_outI = (_179_outI) + (BigInteger.One); } - _172_earlyReturn = Dafny.Sequence.Concat(_172_earlyReturn, Dafny.Sequence.UnicodeFromString(");")); + _176_earlyReturn = Dafny.Sequence.Concat(_176_earlyReturn, Dafny.Sequence.UnicodeFromString(");")); } } else { } - Dafny.ISequence _177_body; - Dafny.ISet> _178___v8; - Dafny.ISequence _out43; - Dafny.ISet> _out44; - DCOMP.COMP.GenStmts((m).dtor_body, _161_paramNames, _172_earlyReturn, out _out43, out _out44); - _177_body = _out43; - _178___v8 = _out44; + Dafny.ISequence _181_body; + Dafny.ISet> _182___v9; + Dafny.ISequence _out45; + Dafny.ISet> _out46; + DCOMP.COMP.GenStmts((m).dtor_body, _165_paramNames, true, _176_earlyReturn, out _out45, out _out46); + _181_body = _out45; + _182___v9 = _out46; DAST._IOptional>> _source11 = (m).dtor_outVars; if (_source11.is_Some) { - Dafny.ISequence> _179___mcc_h1 = _source11.dtor_Some_a0; - Dafny.ISequence> _180_outVars = _179___mcc_h1; + Dafny.ISequence> _183___mcc_h1 = _source11.dtor_Some_a0; + Dafny.ISequence> _184_outVars = _183___mcc_h1; { - _177_body = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_177_body, Dafny.Sequence.UnicodeFromString("\n")), _172_earlyReturn); + _181_body = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_181_body, Dafny.Sequence.UnicodeFromString("\n")), _176_earlyReturn); } } else { } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" {\n")), _177_body), Dafny.Sequence.UnicodeFromString("\n}\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" {\n")), _181_body), Dafny.Sequence.UnicodeFromString("\n}\n")); } else { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(";\n")); } return s; } - public static void GenStmts(Dafny.ISequence stmts, Dafny.ISequence> @params, Dafny.ISequence earlyReturn, out Dafny.ISequence generated, out Dafny.ISet> readIdents) { + public static void GenStmts(Dafny.ISequence stmts, Dafny.ISequence> @params, bool isLast, Dafny.ISequence earlyReturn, out Dafny.ISequence generated, out Dafny.ISet> readIdents) { generated = Dafny.Sequence.Empty; readIdents = Dafny.Set>.Empty; generated = Dafny.Sequence.UnicodeFromString(""); readIdents = Dafny.Set>.FromElements(); - BigInteger _181_i; - _181_i = BigInteger.Zero; - while ((_181_i) < (new BigInteger((stmts).Count))) { - DAST._IStatement _182_stmt; - _182_stmt = (stmts).Select(_181_i); - Dafny.ISequence _183_stmtString; - Dafny.ISet> _184_recIdents; - Dafny.ISequence _out45; - Dafny.ISet> _out46; - DCOMP.COMP.GenStmt(_182_stmt, @params, earlyReturn, out _out45, out _out46); - _183_stmtString = _out45; - _184_recIdents = _out46; - readIdents = Dafny.Set>.Union(readIdents, _184_recIdents); - if ((_181_i).Sign == 1) { + BigInteger _185_i; + _185_i = BigInteger.Zero; + while ((_185_i) < (new BigInteger((stmts).Count))) { + DAST._IStatement _186_stmt; + _186_stmt = (stmts).Select(_185_i); + Dafny.ISequence _187_stmtString; + Dafny.ISet> _188_recIdents; + Dafny.ISequence _out47; + Dafny.ISet> _out48; + DCOMP.COMP.GenStmt(_186_stmt, @params, (isLast) && ((_185_i) == ((new BigInteger((stmts).Count)) - (BigInteger.One))), earlyReturn, out _out47, out _out48); + _187_stmtString = _out47; + _188_recIdents = _out48; + readIdents = Dafny.Set>.Union(readIdents, _188_recIdents); + if ((_185_i).Sign == 1) { generated = Dafny.Sequence.Concat(generated, Dafny.Sequence.UnicodeFromString("\n")); } - generated = Dafny.Sequence.Concat(generated, _183_stmtString); - _181_i = (_181_i) + (BigInteger.One); + generated = Dafny.Sequence.Concat(generated, _187_stmtString); + _185_i = (_185_i) + (BigInteger.One); } } - public static void GenStmt(DAST._IStatement stmt, Dafny.ISequence> @params, Dafny.ISequence earlyReturn, out Dafny.ISequence generated, out Dafny.ISet> readIdents) { + public static void GenStmt(DAST._IStatement stmt, Dafny.ISequence> @params, bool isLast, Dafny.ISequence earlyReturn, out Dafny.ISequence generated, out Dafny.ISet> readIdents) { generated = Dafny.Sequence.Empty; readIdents = Dafny.Set>.Empty; DAST._IStatement _source12 = stmt; if (_source12.is_DeclareVar) { - Dafny.ISequence _185___mcc_h0 = _source12.dtor_name; - DAST._IType _186___mcc_h1 = _source12.dtor_typ; - DAST._IOptional _187___mcc_h2 = _source12.dtor_maybeValue; - DAST._IOptional _source13 = _187___mcc_h2; + Dafny.ISequence _189___mcc_h0 = _source12.dtor_name; + DAST._IType _190___mcc_h1 = _source12.dtor_typ; + DAST._IOptional _191___mcc_h2 = _source12.dtor_maybeValue; + DAST._IOptional _source13 = _191___mcc_h2; if (_source13.is_Some) { - DAST._IExpression _188___mcc_h3 = _source13.dtor_Some_a0; - DAST._IExpression _189_expression = _188___mcc_h3; - DAST._IType _190_typ = _186___mcc_h1; - Dafny.ISequence _191_name = _185___mcc_h0; + DAST._IExpression _192___mcc_h3 = _source13.dtor_Some_a0; + DAST._IExpression _193_expression = _192___mcc_h3; + DAST._IType _194_typ = _190___mcc_h1; + Dafny.ISequence _195_name = _189___mcc_h0; { - Dafny.ISequence _192_expr; - bool _193___v9; - Dafny.ISet> _194_recIdents; - Dafny.ISequence _out47; - bool _out48; - Dafny.ISet> _out49; - DCOMP.COMP.GenExpr(_189_expression, @params, true, out _out47, out _out48, out _out49); - _192_expr = _out47; - _193___v9 = _out48; - _194_recIdents = _out49; - Dafny.ISequence _195_typeString; - Dafny.ISequence _out50; - _out50 = DCOMP.COMP.GenType(_190_typ, true, false); - _195_typeString = _out50; - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("let mut r#"), _191_name), Dafny.Sequence.UnicodeFromString(": ")), _195_typeString), Dafny.Sequence.UnicodeFromString(" = ")), _192_expr), Dafny.Sequence.UnicodeFromString(";")); - readIdents = _194_recIdents; + Dafny.ISequence _196_expr; + bool _197___v10; + bool _198_recErased; + Dafny.ISet> _199_recIdents; + Dafny.ISequence _out49; + bool _out50; + bool _out51; + Dafny.ISet> _out52; + DCOMP.COMP.GenExpr(_193_expression, @params, true, out _out49, out _out50, out _out51, out _out52); + _196_expr = _out49; + _197___v10 = _out50; + _198_recErased = _out51; + _199_recIdents = _out52; + if (_198_recErased) { + _196_expr = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _196_expr), Dafny.Sequence.UnicodeFromString(")")); + } + Dafny.ISequence _200_typeString; + Dafny.ISequence _out53; + _out53 = DCOMP.COMP.GenType(_194_typ, true, false); + _200_typeString = _out53; + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("let mut r#"), _195_name), Dafny.Sequence.UnicodeFromString(": ")), _200_typeString), Dafny.Sequence.UnicodeFromString(" = ")), _196_expr), Dafny.Sequence.UnicodeFromString(";")); + readIdents = _199_recIdents; } } else { - DAST._IType _196_typ = _186___mcc_h1; - Dafny.ISequence _197_name = _185___mcc_h0; + DAST._IType _201_typ = _190___mcc_h1; + Dafny.ISequence _202_name = _189___mcc_h0; { - Dafny.ISequence _198_typeString; - Dafny.ISequence _out51; - _out51 = DCOMP.COMP.GenType(_196_typ, true, false); - _198_typeString = _out51; - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("let mut r#"), _197_name), Dafny.Sequence.UnicodeFromString(": ")), _198_typeString), Dafny.Sequence.UnicodeFromString(";")); + Dafny.ISequence _203_typeString; + Dafny.ISequence _out54; + _out54 = DCOMP.COMP.GenType(_201_typ, true, false); + _203_typeString = _out54; + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("let mut r#"), _202_name), Dafny.Sequence.UnicodeFromString(": ")), _203_typeString), Dafny.Sequence.UnicodeFromString(";")); readIdents = Dafny.Set>.FromElements(); } } } else if (_source12.is_Assign) { - Dafny.ISequence _199___mcc_h4 = _source12.dtor_name; - DAST._IExpression _200___mcc_h5 = _source12.dtor_value; - DAST._IExpression _201_expression = _200___mcc_h5; - Dafny.ISequence _202_name = _199___mcc_h4; - { - Dafny.ISequence _203_expr; - bool _204___v10; - Dafny.ISet> _205_recIdents; - Dafny.ISequence _out52; - bool _out53; - Dafny.ISet> _out54; - DCOMP.COMP.GenExpr(_201_expression, @params, true, out _out52, out _out53, out _out54); - _203_expr = _out52; - _204___v10 = _out53; - _205_recIdents = _out54; - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), _202_name), Dafny.Sequence.UnicodeFromString(" = ")), _203_expr), Dafny.Sequence.UnicodeFromString(";")); - readIdents = _205_recIdents; - } - } else if (_source12.is_If) { - DAST._IExpression _206___mcc_h6 = _source12.dtor_cond; - Dafny.ISequence _207___mcc_h7 = _source12.dtor_thn; - Dafny.ISequence _208___mcc_h8 = _source12.dtor_els; - Dafny.ISequence _209_els = _208___mcc_h8; - Dafny.ISequence _210_thn = _207___mcc_h7; - DAST._IExpression _211_cond = _206___mcc_h6; + Dafny.ISequence _204___mcc_h4 = _source12.dtor_name; + DAST._IExpression _205___mcc_h5 = _source12.dtor_value; + DAST._IExpression _206_expression = _205___mcc_h5; + Dafny.ISequence _207_name = _204___mcc_h4; { - Dafny.ISequence _212_condString; - bool _213___v11; - Dafny.ISet> _214_recIdents; + Dafny.ISequence _208_expr; + bool _209___v11; + bool _210_recErased; + Dafny.ISet> _211_recIdents; Dafny.ISequence _out55; bool _out56; - Dafny.ISet> _out57; - DCOMP.COMP.GenExpr(_211_cond, @params, true, out _out55, out _out56, out _out57); - _212_condString = _out55; - _213___v11 = _out56; - _214_recIdents = _out57; - readIdents = _214_recIdents; - Dafny.ISequence _215_thnString; - Dafny.ISet> _216_thnIdents; - Dafny.ISequence _out58; - Dafny.ISet> _out59; - DCOMP.COMP.GenStmts(_210_thn, @params, earlyReturn, out _out58, out _out59); - _215_thnString = _out58; - _216_thnIdents = _out59; - readIdents = Dafny.Set>.Union(readIdents, _216_thnIdents); - Dafny.ISequence _217_elsString; - Dafny.ISet> _218_elsIdents; - Dafny.ISequence _out60; - Dafny.ISet> _out61; - DCOMP.COMP.GenStmts(_209_els, @params, earlyReturn, out _out60, out _out61); - _217_elsString = _out60; - _218_elsIdents = _out61; - readIdents = Dafny.Set>.Union(readIdents, _218_elsIdents); - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("if "), _212_condString), Dafny.Sequence.UnicodeFromString(" {\n")), _215_thnString), Dafny.Sequence.UnicodeFromString("\n} else {\n")), _217_elsString), Dafny.Sequence.UnicodeFromString("\n}")); + bool _out57; + Dafny.ISet> _out58; + DCOMP.COMP.GenExpr(_206_expression, @params, true, out _out55, out _out56, out _out57, out _out58); + _208_expr = _out55; + _209___v11 = _out56; + _210_recErased = _out57; + _211_recIdents = _out58; + if (_210_recErased) { + _208_expr = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _208_expr), Dafny.Sequence.UnicodeFromString(")")); + } + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), _207_name), Dafny.Sequence.UnicodeFromString(" = ")), _208_expr), Dafny.Sequence.UnicodeFromString(";")); + readIdents = _211_recIdents; } - } else if (_source12.is_While) { - DAST._IExpression _219___mcc_h9 = _source12.dtor_cond; - Dafny.ISequence _220___mcc_h10 = _source12.dtor_body; - Dafny.ISequence _221_body = _220___mcc_h10; - DAST._IExpression _222_cond = _219___mcc_h9; + } else if (_source12.is_If) { + DAST._IExpression _212___mcc_h6 = _source12.dtor_cond; + Dafny.ISequence _213___mcc_h7 = _source12.dtor_thn; + Dafny.ISequence _214___mcc_h8 = _source12.dtor_els; + Dafny.ISequence _215_els = _214___mcc_h8; + Dafny.ISequence _216_thn = _213___mcc_h7; + DAST._IExpression _217_cond = _212___mcc_h6; { - Dafny.ISequence _223_condString; - bool _224___v12; - Dafny.ISet> _225_recIdents; - Dafny.ISequence _out62; - bool _out63; + Dafny.ISequence _218_condString; + bool _219___v12; + bool _220_condErased; + Dafny.ISet> _221_recIdents; + Dafny.ISequence _out59; + bool _out60; + bool _out61; + Dafny.ISet> _out62; + DCOMP.COMP.GenExpr(_217_cond, @params, true, out _out59, out _out60, out _out61, out _out62); + _218_condString = _out59; + _219___v12 = _out60; + _220_condErased = _out61; + _221_recIdents = _out62; + if (!(_220_condErased)) { + _218_condString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _218_condString), Dafny.Sequence.UnicodeFromString(")")); + } + readIdents = _221_recIdents; + Dafny.ISequence _222_thnString; + Dafny.ISet> _223_thnIdents; + Dafny.ISequence _out63; Dafny.ISet> _out64; - DCOMP.COMP.GenExpr(_222_cond, @params, true, out _out62, out _out63, out _out64); - _223_condString = _out62; - _224___v12 = _out63; - _225_recIdents = _out64; - readIdents = _225_recIdents; - Dafny.ISequence _226_bodyString; - Dafny.ISet> _227_bodyIdents; + DCOMP.COMP.GenStmts(_216_thn, @params, isLast, earlyReturn, out _out63, out _out64); + _222_thnString = _out63; + _223_thnIdents = _out64; + readIdents = Dafny.Set>.Union(readIdents, _223_thnIdents); + Dafny.ISequence _224_elsString; + Dafny.ISet> _225_elsIdents; Dafny.ISequence _out65; Dafny.ISet> _out66; - DCOMP.COMP.GenStmts(_221_body, @params, earlyReturn, out _out65, out _out66); - _226_bodyString = _out65; - _227_bodyIdents = _out66; - readIdents = Dafny.Set>.Union(readIdents, _227_bodyIdents); - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("while "), _223_condString), Dafny.Sequence.UnicodeFromString(" {\n")), _226_bodyString), Dafny.Sequence.UnicodeFromString("\n}")); + DCOMP.COMP.GenStmts(_215_els, @params, isLast, earlyReturn, out _out65, out _out66); + _224_elsString = _out65; + _225_elsIdents = _out66; + readIdents = Dafny.Set>.Union(readIdents, _225_elsIdents); + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("if "), _218_condString), Dafny.Sequence.UnicodeFromString(" {\n")), _222_thnString), Dafny.Sequence.UnicodeFromString("\n} else {\n")), _224_elsString), Dafny.Sequence.UnicodeFromString("\n}")); + } + } else if (_source12.is_While) { + DAST._IExpression _226___mcc_h9 = _source12.dtor_cond; + Dafny.ISequence _227___mcc_h10 = _source12.dtor_body; + Dafny.ISequence _228_body = _227___mcc_h10; + DAST._IExpression _229_cond = _226___mcc_h9; + { + Dafny.ISequence _230_condString; + bool _231___v13; + bool _232_condErased; + Dafny.ISet> _233_recIdents; + Dafny.ISequence _out67; + bool _out68; + bool _out69; + Dafny.ISet> _out70; + DCOMP.COMP.GenExpr(_229_cond, @params, true, out _out67, out _out68, out _out69, out _out70); + _230_condString = _out67; + _231___v13 = _out68; + _232_condErased = _out69; + _233_recIdents = _out70; + if (!(_232_condErased)) { + _230_condString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase("), _230_condString), Dafny.Sequence.UnicodeFromString(")")); + } + readIdents = _233_recIdents; + Dafny.ISequence _234_bodyString; + Dafny.ISet> _235_bodyIdents; + Dafny.ISequence _out71; + Dafny.ISet> _out72; + DCOMP.COMP.GenStmts(_228_body, @params, false, earlyReturn, out _out71, out _out72); + _234_bodyString = _out71; + _235_bodyIdents = _out72; + readIdents = Dafny.Set>.Union(readIdents, _235_bodyIdents); + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("while "), _230_condString), Dafny.Sequence.UnicodeFromString(" {\n")), _234_bodyString), Dafny.Sequence.UnicodeFromString("\n}")); } } else if (_source12.is_Call) { - DAST._IExpression _228___mcc_h11 = _source12.dtor_on; - Dafny.ISequence _229___mcc_h12 = _source12.dtor_name; - Dafny.ISequence _230___mcc_h13 = _source12.dtor_typeArgs; - Dafny.ISequence _231___mcc_h14 = _source12.dtor_args; - DAST._IOptional>> _232___mcc_h15 = _source12.dtor_outs; - DAST._IOptional>> _233_maybeOutVars = _232___mcc_h15; - Dafny.ISequence _234_args = _231___mcc_h14; - Dafny.ISequence _235_typeArgs = _230___mcc_h13; - Dafny.ISequence _236_name = _229___mcc_h12; - DAST._IExpression _237_on = _228___mcc_h11; + DAST._IExpression _236___mcc_h11 = _source12.dtor_on; + Dafny.ISequence _237___mcc_h12 = _source12.dtor_name; + Dafny.ISequence _238___mcc_h13 = _source12.dtor_typeArgs; + Dafny.ISequence _239___mcc_h14 = _source12.dtor_args; + DAST._IOptional>> _240___mcc_h15 = _source12.dtor_outs; + DAST._IOptional>> _241_maybeOutVars = _240___mcc_h15; + Dafny.ISequence _242_args = _239___mcc_h14; + Dafny.ISequence _243_typeArgs = _238___mcc_h13; + Dafny.ISequence _244_name = _237___mcc_h12; + DAST._IExpression _245_on = _236___mcc_h11; { readIdents = Dafny.Set>.FromElements(); - Dafny.ISequence _238_typeArgString; - _238_typeArgString = Dafny.Sequence.UnicodeFromString(""); - if ((new BigInteger((_235_typeArgs).Count)) >= (BigInteger.One)) { - BigInteger _239_typeI; - _239_typeI = BigInteger.Zero; - _238_typeArgString = Dafny.Sequence.UnicodeFromString("::<"); - while ((_239_typeI) < (new BigInteger((_235_typeArgs).Count))) { - if ((_239_typeI).Sign == 1) { - _238_typeArgString = Dafny.Sequence.Concat(_238_typeArgString, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _246_typeArgString; + _246_typeArgString = Dafny.Sequence.UnicodeFromString(""); + if ((new BigInteger((_243_typeArgs).Count)) >= (BigInteger.One)) { + BigInteger _247_typeI; + _247_typeI = BigInteger.Zero; + _246_typeArgString = Dafny.Sequence.UnicodeFromString("::<"); + while ((_247_typeI) < (new BigInteger((_243_typeArgs).Count))) { + if ((_247_typeI).Sign == 1) { + _246_typeArgString = Dafny.Sequence.Concat(_246_typeArgString, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _240_typeString; - Dafny.ISequence _out67; - _out67 = DCOMP.COMP.GenType((_235_typeArgs).Select(_239_typeI), false, false); - _240_typeString = _out67; - _238_typeArgString = Dafny.Sequence.Concat(_238_typeArgString, _240_typeString); - _239_typeI = (_239_typeI) + (BigInteger.One); + Dafny.ISequence _248_typeString; + Dafny.ISequence _out73; + _out73 = DCOMP.COMP.GenType((_243_typeArgs).Select(_247_typeI), false, false); + _248_typeString = _out73; + _246_typeArgString = Dafny.Sequence.Concat(_246_typeArgString, _248_typeString); + _247_typeI = (_247_typeI) + (BigInteger.One); } - _238_typeArgString = Dafny.Sequence.Concat(_238_typeArgString, Dafny.Sequence.UnicodeFromString(">")); + _246_typeArgString = Dafny.Sequence.Concat(_246_typeArgString, Dafny.Sequence.UnicodeFromString(">")); } - Dafny.ISequence _241_argString; - _241_argString = Dafny.Sequence.UnicodeFromString(""); - BigInteger _242_i; - _242_i = BigInteger.Zero; - while ((_242_i) < (new BigInteger((_234_args).Count))) { - if ((_242_i).Sign == 1) { - _241_argString = Dafny.Sequence.Concat(_241_argString, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _249_argString; + _249_argString = Dafny.Sequence.UnicodeFromString(""); + BigInteger _250_i; + _250_i = BigInteger.Zero; + while ((_250_i) < (new BigInteger((_242_args).Count))) { + if ((_250_i).Sign == 1) { + _249_argString = Dafny.Sequence.Concat(_249_argString, Dafny.Sequence.UnicodeFromString(", ")); + } + Dafny.ISequence _251_argExpr; + bool _252_isOwned; + bool _253_argErased; + Dafny.ISet> _254_argIdents; + Dafny.ISequence _out74; + bool _out75; + bool _out76; + Dafny.ISet> _out77; + DCOMP.COMP.GenExpr((_242_args).Select(_250_i), @params, false, out _out74, out _out75, out _out76, out _out77); + _251_argExpr = _out74; + _252_isOwned = _out75; + _253_argErased = _out76; + _254_argIdents = _out77; + if (_252_isOwned) { + _251_argExpr = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("&"), _251_argExpr); } - Dafny.ISequence _243_argExpr; - bool _244_isOwned; - Dafny.ISet> _245_argIdents; - Dafny.ISequence _out68; - bool _out69; - Dafny.ISet> _out70; - DCOMP.COMP.GenExpr((_234_args).Select(_242_i), @params, false, out _out68, out _out69, out _out70); - _243_argExpr = _out68; - _244_isOwned = _out69; - _245_argIdents = _out70; - _241_argString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_241_argString, ((_244_isOwned) ? (Dafny.Sequence.UnicodeFromString("&")) : (Dafny.Sequence.UnicodeFromString("")))), _243_argExpr); - readIdents = Dafny.Set>.Union(readIdents, _245_argIdents); - _242_i = (_242_i) + (BigInteger.One); + _249_argString = Dafny.Sequence.Concat(_249_argString, _251_argExpr); + readIdents = Dafny.Set>.Union(readIdents, _254_argIdents); + _250_i = (_250_i) + (BigInteger.One); } - Dafny.ISequence _246_enclosingString; - bool _247___v13; - Dafny.ISet> _248_enclosingIdents; - Dafny.ISequence _out71; - bool _out72; - Dafny.ISet> _out73; - DCOMP.COMP.GenExpr(_237_on, @params, true, out _out71, out _out72, out _out73); - _246_enclosingString = _out71; - _247___v13 = _out72; - _248_enclosingIdents = _out73; - readIdents = Dafny.Set>.Union(readIdents, _248_enclosingIdents); - DAST._IExpression _source14 = _237_on; + Dafny.ISequence _255_enclosingString; + bool _256___v14; + bool _257___v15; + Dafny.ISet> _258_enclosingIdents; + Dafny.ISequence _out78; + bool _out79; + bool _out80; + Dafny.ISet> _out81; + DCOMP.COMP.GenExpr(_245_on, @params, true, out _out78, out _out79, out _out80, out _out81); + _255_enclosingString = _out78; + _256___v14 = _out79; + _257___v15 = _out80; + _258_enclosingIdents = _out81; + readIdents = Dafny.Set>.Union(readIdents, _258_enclosingIdents); + DAST._IExpression _source14 = _245_on; if (_source14.is_Literal) { - DAST._ILiteral _249___mcc_h18 = _source14.dtor_Literal_a0; + DAST._ILiteral _259___mcc_h18 = _source14.dtor_Literal_a0; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Ident) { - Dafny.ISequence _250___mcc_h20 = _source14.dtor_Ident_a0; + Dafny.ISequence _260___mcc_h20 = _source14.dtor_Ident_a0; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Companion) { - Dafny.ISequence> _251___mcc_h22 = _source14.dtor_Companion_a0; + Dafny.ISequence> _261___mcc_h22 = _source14.dtor_Companion_a0; { - _246_enclosingString = Dafny.Sequence.Concat(_246_enclosingString, Dafny.Sequence.UnicodeFromString("::")); + _255_enclosingString = Dafny.Sequence.Concat(_255_enclosingString, Dafny.Sequence.UnicodeFromString("::")); } } else if (_source14.is_Tuple) { - Dafny.ISequence _252___mcc_h24 = _source14.dtor_Tuple_a0; + Dafny.ISequence _262___mcc_h24 = _source14.dtor_Tuple_a0; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_New) { - Dafny.ISequence> _253___mcc_h26 = _source14.dtor_path; - Dafny.ISequence _254___mcc_h27 = _source14.dtor_args; + Dafny.ISequence> _263___mcc_h26 = _source14.dtor_path; + Dafny.ISequence _264___mcc_h27 = _source14.dtor_args; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_NewArray) { - Dafny.ISequence _255___mcc_h30 = _source14.dtor_dims; + Dafny.ISequence _265___mcc_h30 = _source14.dtor_dims; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_DatatypeValue) { - Dafny.ISequence> _256___mcc_h32 = _source14.dtor_path; - Dafny.ISequence _257___mcc_h33 = _source14.dtor_variant; - bool _258___mcc_h34 = _source14.dtor_isCo; - Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _259___mcc_h35 = _source14.dtor_contents; + Dafny.ISequence> _266___mcc_h32 = _source14.dtor_path; + Dafny.ISequence _267___mcc_h33 = _source14.dtor_variant; + bool _268___mcc_h34 = _source14.dtor_isCo; + Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _269___mcc_h35 = _source14.dtor_contents; + { + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + } + } else if (_source14.is_SubsetUpgrade) { + DAST._IExpression _270___mcc_h40 = _source14.dtor_value; + DAST._IType _271___mcc_h41 = _source14.dtor_typ; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } - } else if (_source14.is_NewtypeValue) { - DAST._IType _260___mcc_h40 = _source14.dtor_tpe; - DAST._IExpression _261___mcc_h41 = _source14.dtor_value; + } else if (_source14.is_SubsetDowngrade) { + DAST._IExpression _272___mcc_h44 = _source14.dtor_value; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_SeqValue) { - Dafny.ISequence _262___mcc_h44 = _source14.dtor_elements; + Dafny.ISequence _273___mcc_h46 = _source14.dtor_elements; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_SetValue) { - Dafny.ISequence _263___mcc_h46 = _source14.dtor_elements; + Dafny.ISequence _274___mcc_h48 = _source14.dtor_elements; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_This) { { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Ite) { - DAST._IExpression _264___mcc_h48 = _source14.dtor_cond; - DAST._IExpression _265___mcc_h49 = _source14.dtor_thn; - DAST._IExpression _266___mcc_h50 = _source14.dtor_els; + DAST._IExpression _275___mcc_h50 = _source14.dtor_cond; + DAST._IExpression _276___mcc_h51 = _source14.dtor_thn; + DAST._IExpression _277___mcc_h52 = _source14.dtor_els; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_UnOp) { - DAST._IUnaryOp _267___mcc_h54 = _source14.dtor_unOp; - DAST._IExpression _268___mcc_h55 = _source14.dtor_expr; + DAST._IUnaryOp _278___mcc_h56 = _source14.dtor_unOp; + DAST._IExpression _279___mcc_h57 = _source14.dtor_expr; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_BinOp) { - Dafny.ISequence _269___mcc_h58 = _source14.dtor_op; - DAST._IExpression _270___mcc_h59 = _source14.dtor_left; - DAST._IExpression _271___mcc_h60 = _source14.dtor_right; + Dafny.ISequence _280___mcc_h60 = _source14.dtor_op; + DAST._IExpression _281___mcc_h61 = _source14.dtor_left; + DAST._IExpression _282___mcc_h62 = _source14.dtor_right; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Select) { - DAST._IExpression _272___mcc_h64 = _source14.dtor_expr; - Dafny.ISequence _273___mcc_h65 = _source14.dtor_field; - bool _274___mcc_h66 = _source14.dtor_onDatatype; + DAST._IExpression _283___mcc_h66 = _source14.dtor_expr; + Dafny.ISequence _284___mcc_h67 = _source14.dtor_field; + bool _285___mcc_h68 = _source14.dtor_onDatatype; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_SelectFn) { - DAST._IExpression _275___mcc_h70 = _source14.dtor_expr; - Dafny.ISequence _276___mcc_h71 = _source14.dtor_field; - bool _277___mcc_h72 = _source14.dtor_onDatatype; - bool _278___mcc_h73 = _source14.dtor_isStatic; - BigInteger _279___mcc_h74 = _source14.dtor_arity; + DAST._IExpression _286___mcc_h72 = _source14.dtor_expr; + Dafny.ISequence _287___mcc_h73 = _source14.dtor_field; + bool _288___mcc_h74 = _source14.dtor_onDatatype; + bool _289___mcc_h75 = _source14.dtor_isStatic; + BigInteger _290___mcc_h76 = _source14.dtor_arity; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_TupleSelect) { - DAST._IExpression _280___mcc_h80 = _source14.dtor_expr; - BigInteger _281___mcc_h81 = _source14.dtor_index; + DAST._IExpression _291___mcc_h82 = _source14.dtor_expr; + BigInteger _292___mcc_h83 = _source14.dtor_index; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Call) { - DAST._IExpression _282___mcc_h84 = _source14.dtor_on; - Dafny.ISequence _283___mcc_h85 = _source14.dtor_name; - Dafny.ISequence _284___mcc_h86 = _source14.dtor_typeArgs; - Dafny.ISequence _285___mcc_h87 = _source14.dtor_args; + DAST._IExpression _293___mcc_h86 = _source14.dtor_on; + Dafny.ISequence _294___mcc_h87 = _source14.dtor_name; + Dafny.ISequence _295___mcc_h88 = _source14.dtor_typeArgs; + Dafny.ISequence _296___mcc_h89 = _source14.dtor_args; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Lambda) { - Dafny.ISequence _286___mcc_h92 = _source14.dtor_params; - Dafny.ISequence _287___mcc_h93 = _source14.dtor_body; + Dafny.ISequence _297___mcc_h94 = _source14.dtor_params; + DAST._IType _298___mcc_h95 = _source14.dtor_retType; + Dafny.ISequence _299___mcc_h96 = _source14.dtor_body; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_IIFE) { - Dafny.ISequence _288___mcc_h96 = _source14.dtor_name; - DAST._IType _289___mcc_h97 = _source14.dtor_typ; - DAST._IExpression _290___mcc_h98 = _source14.dtor_value; - DAST._IExpression _291___mcc_h99 = _source14.dtor_iifeBody; + Dafny.ISequence _300___mcc_h100 = _source14.dtor_name; + DAST._IType _301___mcc_h101 = _source14.dtor_typ; + DAST._IExpression _302___mcc_h102 = _source14.dtor_value; + DAST._IExpression _303___mcc_h103 = _source14.dtor_iifeBody; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_Apply) { - DAST._IExpression _292___mcc_h104 = _source14.dtor_expr; - Dafny.ISequence _293___mcc_h105 = _source14.dtor_args; + DAST._IExpression _304___mcc_h108 = _source14.dtor_expr; + Dafny.ISequence _305___mcc_h109 = _source14.dtor_args; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source14.is_TypeTest) { - DAST._IExpression _294___mcc_h108 = _source14.dtor_on; - Dafny.ISequence> _295___mcc_h109 = _source14.dtor_dType; - Dafny.ISequence _296___mcc_h110 = _source14.dtor_variant; + DAST._IExpression _306___mcc_h112 = _source14.dtor_on; + Dafny.ISequence> _307___mcc_h113 = _source14.dtor_dType; + Dafny.ISequence _308___mcc_h114 = _source14.dtor_variant; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else { - DAST._IType _297___mcc_h114 = _source14.dtor_typ; + DAST._IType _309___mcc_h118 = _source14.dtor_typ; { - _246_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _246_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _255_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _255_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } - Dafny.ISequence _298_receiver; - _298_receiver = Dafny.Sequence.UnicodeFromString(""); - DAST._IOptional>> _source15 = _233_maybeOutVars; + Dafny.ISequence _310_receiver; + _310_receiver = Dafny.Sequence.UnicodeFromString(""); + DAST._IOptional>> _source15 = _241_maybeOutVars; if (_source15.is_Some) { - Dafny.ISequence> _299___mcc_h116 = _source15.dtor_Some_a0; - Dafny.ISequence> _300_outVars = _299___mcc_h116; + Dafny.ISequence> _311___mcc_h120 = _source15.dtor_Some_a0; + Dafny.ISequence> _312_outVars = _311___mcc_h120; { - if ((new BigInteger((_300_outVars).Count)) > (BigInteger.One)) { - _298_receiver = Dafny.Sequence.UnicodeFromString("("); + if ((new BigInteger((_312_outVars).Count)) > (BigInteger.One)) { + _310_receiver = Dafny.Sequence.UnicodeFromString("("); } - BigInteger _301_outI; - _301_outI = BigInteger.Zero; - while ((_301_outI) < (new BigInteger((_300_outVars).Count))) { - if ((_301_outI).Sign == 1) { - _298_receiver = Dafny.Sequence.Concat(_298_receiver, Dafny.Sequence.UnicodeFromString(", ")); + BigInteger _313_outI; + _313_outI = BigInteger.Zero; + while ((_313_outI) < (new BigInteger((_312_outVars).Count))) { + if ((_313_outI).Sign == 1) { + _310_receiver = Dafny.Sequence.Concat(_310_receiver, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _302_outVar; - _302_outVar = (_300_outVars).Select(_301_outI); - _298_receiver = Dafny.Sequence.Concat(_298_receiver, (_302_outVar)); - _301_outI = (_301_outI) + (BigInteger.One); + Dafny.ISequence _314_outVar; + _314_outVar = (_312_outVars).Select(_313_outI); + _310_receiver = Dafny.Sequence.Concat(_310_receiver, (_314_outVar)); + _313_outI = (_313_outI) + (BigInteger.One); } - if ((new BigInteger((_300_outVars).Count)) > (BigInteger.One)) { - _298_receiver = Dafny.Sequence.Concat(_298_receiver, Dafny.Sequence.UnicodeFromString(")")); + if ((new BigInteger((_312_outVars).Count)) > (BigInteger.One)) { + _310_receiver = Dafny.Sequence.Concat(_310_receiver, Dafny.Sequence.UnicodeFromString(")")); } } } else { } - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(((!(_298_receiver).Equals(Dafny.Sequence.UnicodeFromString(""))) ? (Dafny.Sequence.Concat(_298_receiver, Dafny.Sequence.UnicodeFromString(" = "))) : (Dafny.Sequence.UnicodeFromString(""))), _246_enclosingString), Dafny.Sequence.UnicodeFromString("r#")), _236_name), _238_typeArgString), Dafny.Sequence.UnicodeFromString("(")), _241_argString), Dafny.Sequence.UnicodeFromString(");")); + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(((!(_310_receiver).Equals(Dafny.Sequence.UnicodeFromString(""))) ? (Dafny.Sequence.Concat(_310_receiver, Dafny.Sequence.UnicodeFromString(" = "))) : (Dafny.Sequence.UnicodeFromString(""))), _255_enclosingString), Dafny.Sequence.UnicodeFromString("r#")), _244_name), _246_typeArgString), Dafny.Sequence.UnicodeFromString("(")), _249_argString), Dafny.Sequence.UnicodeFromString(");")); } } else if (_source12.is_Return) { - DAST._IExpression _303___mcc_h16 = _source12.dtor_expr; - DAST._IExpression _304_expr = _303___mcc_h16; + DAST._IExpression _315___mcc_h16 = _source12.dtor_expr; + DAST._IExpression _316_expr = _315___mcc_h16; { - Dafny.ISequence _305_exprString; - bool _306___v16; - Dafny.ISet> _307_recIdents; - Dafny.ISequence _out74; - bool _out75; - Dafny.ISet> _out76; - DCOMP.COMP.GenExpr(_304_expr, @params, true, out _out74, out _out75, out _out76); - _305_exprString = _out74; - _306___v16 = _out75; - _307_recIdents = _out76; - readIdents = _307_recIdents; - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("return "), _305_exprString), Dafny.Sequence.UnicodeFromString(";")); + Dafny.ISequence _317_exprString; + bool _318___v18; + bool _319_recErased; + Dafny.ISet> _320_recIdents; + Dafny.ISequence _out82; + bool _out83; + bool _out84; + Dafny.ISet> _out85; + DCOMP.COMP.GenExpr(_316_expr, @params, true, out _out82, out _out83, out _out84, out _out85); + _317_exprString = _out82; + _318___v18 = _out83; + _319_recErased = _out84; + _320_recIdents = _out85; + _317_exprString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _317_exprString), Dafny.Sequence.UnicodeFromString(")")); + readIdents = _320_recIdents; + if (isLast) { + generated = _317_exprString; + } else { + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("return "), _317_exprString), Dafny.Sequence.UnicodeFromString(";")); + } } } else if (_source12.is_EarlyReturn) { { @@ -5038,380 +5180,496 @@ public static void GenStmt(DAST._IStatement stmt, Dafny.ISequence>.FromElements(); } } else { - DAST._IExpression _308___mcc_h17 = _source12.dtor_Print_a0; - DAST._IExpression _309_e = _308___mcc_h17; + DAST._IExpression _321___mcc_h17 = _source12.dtor_Print_a0; + DAST._IExpression _322_e = _321___mcc_h17; { - Dafny.ISequence _310_printedExpr; - bool _311_isOwned; - Dafny.ISet> _312_recIdents; - Dafny.ISequence _out77; - bool _out78; - Dafny.ISet> _out79; - DCOMP.COMP.GenExpr(_309_e, @params, false, out _out77, out _out78, out _out79); - _310_printedExpr = _out77; - _311_isOwned = _out78; - _312_recIdents = _out79; - generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("print!(\"{}\", ::dafny_runtime::DafnyPrintWrapper("), ((_311_isOwned) ? (Dafny.Sequence.UnicodeFromString("&")) : (Dafny.Sequence.UnicodeFromString("")))), _310_printedExpr), Dafny.Sequence.UnicodeFromString("));")); - readIdents = _312_recIdents; + Dafny.ISequence _323_printedExpr; + bool _324_isOwned; + bool _325___v19; + Dafny.ISet> _326_recIdents; + Dafny.ISequence _out86; + bool _out87; + bool _out88; + Dafny.ISet> _out89; + DCOMP.COMP.GenExpr(_322_e, @params, false, out _out86, out _out87, out _out88, out _out89); + _323_printedExpr = _out86; + _324_isOwned = _out87; + _325___v19 = _out88; + _326_recIdents = _out89; + generated = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("print!(\"{}\", ::dafny_runtime::DafnyPrintWrapper("), ((_324_isOwned) ? (Dafny.Sequence.UnicodeFromString("&")) : (Dafny.Sequence.UnicodeFromString("")))), _323_printedExpr), Dafny.Sequence.UnicodeFromString("));")); + readIdents = _326_recIdents; } } } - public static void GenExpr(DAST._IExpression e, Dafny.ISequence> @params, bool mustOwn, out Dafny.ISequence s, out bool isOwned, out Dafny.ISet> readIdents) { + public static void GenExpr(DAST._IExpression e, Dafny.ISequence> @params, bool mustOwn, out Dafny.ISequence s, out bool isOwned, out bool isErased, out Dafny.ISet> readIdents) { s = Dafny.Sequence.Empty; isOwned = false; + isErased = false; readIdents = Dafny.Set>.Empty; DAST._IExpression _source16 = e; if (_source16.is_Literal) { - DAST._ILiteral _313___mcc_h0 = _source16.dtor_Literal_a0; - DAST._ILiteral _source17 = _313___mcc_h0; + DAST._ILiteral _327___mcc_h0 = _source16.dtor_Literal_a0; + DAST._ILiteral _source17 = _327___mcc_h0; if (_source17.is_BoolLiteral) { - bool _314___mcc_h1 = _source17.dtor_BoolLiteral_a0; - if ((_314___mcc_h1) == (false)) { + bool _328___mcc_h1 = _source17.dtor_BoolLiteral_a0; + if ((_328___mcc_h1) == (false)) { { s = Dafny.Sequence.UnicodeFromString("false"); isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } else { { s = Dafny.Sequence.UnicodeFromString("true"); isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } } else if (_source17.is_IntLiteral) { - BigInteger _315___mcc_h2 = _source17.dtor_IntLiteral_a0; - BigInteger _316_i = _315___mcc_h2; + BigInteger _329___mcc_h2 = _source17.dtor_IntLiteral_a0; + BigInteger _330_i = _329___mcc_h2; { - if ((_316_i).Sign == -1) { - s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("-"), DCOMP.__default.natToString((BigInteger.Zero) - (_316_i))); + if ((_330_i).Sign == -1) { + s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("-"), DCOMP.__default.natToString((BigInteger.Zero) - (_330_i))); } else { - s = DCOMP.__default.natToString(_316_i); + s = DCOMP.__default.natToString(_330_i); } isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } else if (_source17.is_DecLiteral) { - Dafny.ISequence _317___mcc_h3 = _source17.dtor_DecLiteral_a0; - Dafny.ISequence _318_l = _317___mcc_h3; + Dafny.ISequence _331___mcc_h3 = _source17.dtor_DecLiteral_a0; + Dafny.ISequence _332_l = _331___mcc_h3; { - s = _318_l; + s = _332_l; isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } else if (_source17.is_StringLiteral) { - Dafny.ISequence _319___mcc_h4 = _source17.dtor_StringLiteral_a0; - Dafny.ISequence _320_l = _319___mcc_h4; + Dafny.ISequence _333___mcc_h4 = _source17.dtor_StringLiteral_a0; + Dafny.ISequence _334_l = _333___mcc_h4; { - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("\""), _320_l), Dafny.Sequence.UnicodeFromString("\".chars().collect::>()")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("\""), _334_l), Dafny.Sequence.UnicodeFromString("\".chars().collect::>()")); isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } else if (_source17.is_CharLiteral) { - Dafny.Rune _321___mcc_h5 = _source17.dtor_CharLiteral_a0; - Dafny.Rune _322_c = _321___mcc_h5; + Dafny.Rune _335___mcc_h5 = _source17.dtor_CharLiteral_a0; + Dafny.Rune _336_c = _335___mcc_h5; { - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::primitive::char::from_u32("), DCOMP.__default.natToString(new BigInteger((_322_c).Value))), Dafny.Sequence.UnicodeFromString(").unwrap()")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::primitive::char::from_u32("), DCOMP.__default.natToString(new BigInteger((_336_c).Value))), Dafny.Sequence.UnicodeFromString(").unwrap()")); isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } else { { s = Dafny.Sequence.UnicodeFromString("None"); isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } } else if (_source16.is_Ident) { - Dafny.ISequence _323___mcc_h6 = _source16.dtor_Ident_a0; - Dafny.ISequence _324_name = _323___mcc_h6; + Dafny.ISequence _337___mcc_h6 = _source16.dtor_Ident_a0; + Dafny.ISequence _338_name = _337___mcc_h6; { - s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), _324_name); - if ((@params).Contains(_324_name)) { - if (mustOwn) { - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(".clone()")); - isOwned = true; - } else { - isOwned = false; - } + s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("r#"), _338_name); + if (!((@params).Contains(_338_name))) { + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("(&"), s), Dafny.Sequence.UnicodeFromString(")")); + } + if (mustOwn) { + s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(".clone()")); + isOwned = true; } else { - if (mustOwn) { - s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(".clone()")); - isOwned = true; - } else { - s = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("&"), s); - isOwned = false; - } + isOwned = false; } - readIdents = Dafny.Set>.FromElements(_324_name); + isErased = false; + readIdents = Dafny.Set>.FromElements(_338_name); } } else if (_source16.is_Companion) { - Dafny.ISequence> _325___mcc_h7 = _source16.dtor_Companion_a0; - Dafny.ISequence> _326_path = _325___mcc_h7; + Dafny.ISequence> _339___mcc_h7 = _source16.dtor_Companion_a0; + Dafny.ISequence> _340_path = _339___mcc_h7; { - Dafny.ISequence _out80; - _out80 = DCOMP.COMP.GenPath(_326_path); - s = _out80; + Dafny.ISequence _out90; + _out90 = DCOMP.COMP.GenPath(_340_path); + s = _out90; isOwned = true; + isErased = true; readIdents = Dafny.Set>.FromElements(); } } else if (_source16.is_Tuple) { - Dafny.ISequence _327___mcc_h8 = _source16.dtor_Tuple_a0; - Dafny.ISequence _328_values = _327___mcc_h8; + Dafny.ISequence _341___mcc_h8 = _source16.dtor_Tuple_a0; + Dafny.ISequence _342_values = _341___mcc_h8; { s = Dafny.Sequence.UnicodeFromString("("); readIdents = Dafny.Set>.FromElements(); - BigInteger _329_i; - _329_i = BigInteger.Zero; - while ((_329_i) < (new BigInteger((_328_values).Count))) { - if ((_329_i).Sign == 1) { + BigInteger _343_i; + _343_i = BigInteger.Zero; + bool _344_allErased; + _344_allErased = true; + while ((_343_i) < (new BigInteger((_342_values).Count))) { + Dafny.ISequence _345___v20; + bool _346___v21; + bool _347_isErased; + Dafny.ISet> _348___v22; + Dafny.ISequence _out91; + bool _out92; + bool _out93; + Dafny.ISet> _out94; + DCOMP.COMP.GenExpr((_342_values).Select(_343_i), @params, true, out _out91, out _out92, out _out93, out _out94); + _345___v20 = _out91; + _346___v21 = _out92; + _347_isErased = _out93; + _348___v22 = _out94; + _344_allErased = (_344_allErased) && (_347_isErased); + _343_i = (_343_i) + (BigInteger.One); + } + _343_i = BigInteger.Zero; + while ((_343_i) < (new BigInteger((_342_values).Count))) { + if ((_343_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" ")); } - Dafny.ISequence _330_recursiveGen; - bool _331___v17; - Dafny.ISet> _332_recIdents; - Dafny.ISequence _out81; - bool _out82; - Dafny.ISet> _out83; - DCOMP.COMP.GenExpr((_328_values).Select(_329_i), @params, true, out _out81, out _out82, out _out83); - _330_recursiveGen = _out81; - _331___v17 = _out82; - _332_recIdents = _out83; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, _330_recursiveGen), Dafny.Sequence.UnicodeFromString(",")); - readIdents = Dafny.Set>.Union(readIdents, _332_recIdents); - _329_i = (_329_i) + (BigInteger.One); + Dafny.ISequence _349_recursiveGen; + bool _350___v23; + bool _351_isErased; + Dafny.ISet> _352_recIdents; + Dafny.ISequence _out95; + bool _out96; + bool _out97; + Dafny.ISet> _out98; + DCOMP.COMP.GenExpr((_342_values).Select(_343_i), @params, true, out _out95, out _out96, out _out97, out _out98); + _349_recursiveGen = _out95; + _350___v23 = _out96; + _351_isErased = _out97; + _352_recIdents = _out98; + if ((_351_isErased) && (!(_344_allErased))) { + _349_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _349_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, _349_recursiveGen), Dafny.Sequence.UnicodeFromString(",")); + readIdents = Dafny.Set>.Union(readIdents, _352_recIdents); + _343_i = (_343_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(")")); isOwned = true; + isErased = _344_allErased; } } else if (_source16.is_New) { - Dafny.ISequence> _333___mcc_h9 = _source16.dtor_path; - Dafny.ISequence _334___mcc_h10 = _source16.dtor_args; - Dafny.ISequence _335_args = _334___mcc_h10; - Dafny.ISequence> _336_path = _333___mcc_h9; + Dafny.ISequence> _353___mcc_h9 = _source16.dtor_path; + Dafny.ISequence _354___mcc_h10 = _source16.dtor_args; + Dafny.ISequence _355_args = _354___mcc_h10; + Dafny.ISequence> _356_path = _353___mcc_h9; { - Dafny.ISequence _337_path; - Dafny.ISequence _out84; - _out84 = DCOMP.COMP.GenPath(_336_path); - _337_path = _out84; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::rc::Rc::new("), _337_path), Dafny.Sequence.UnicodeFromString("::new(")); + Dafny.ISequence _357_path; + Dafny.ISequence _out99; + _out99 = DCOMP.COMP.GenPath(_356_path); + _357_path = _out99; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::rc::Rc::new("), _357_path), Dafny.Sequence.UnicodeFromString("::new(")); readIdents = Dafny.Set>.FromElements(); - BigInteger _338_i; - _338_i = BigInteger.Zero; - while ((_338_i) < (new BigInteger((_335_args).Count))) { - if ((_338_i).Sign == 1) { + BigInteger _358_i; + _358_i = BigInteger.Zero; + while ((_358_i) < (new BigInteger((_355_args).Count))) { + if ((_358_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _339_recursiveGen; - bool _340___v18; - Dafny.ISet> _341_recIdents; - Dafny.ISequence _out85; - bool _out86; - Dafny.ISet> _out87; - DCOMP.COMP.GenExpr((_335_args).Select(_338_i), @params, true, out _out85, out _out86, out _out87); - _339_recursiveGen = _out85; - _340___v18 = _out86; - _341_recIdents = _out87; - s = Dafny.Sequence.Concat(s, _339_recursiveGen); - readIdents = Dafny.Set>.Union(readIdents, _341_recIdents); - _338_i = (_338_i) + (BigInteger.One); + Dafny.ISequence _359_recursiveGen; + bool _360___v24; + bool _361_isErased; + Dafny.ISet> _362_recIdents; + Dafny.ISequence _out100; + bool _out101; + bool _out102; + Dafny.ISet> _out103; + DCOMP.COMP.GenExpr((_355_args).Select(_358_i), @params, true, out _out100, out _out101, out _out102, out _out103); + _359_recursiveGen = _out100; + _360___v24 = _out101; + _361_isErased = _out102; + _362_recIdents = _out103; + if (_361_isErased) { + _359_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _359_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(s, _359_recursiveGen); + readIdents = Dafny.Set>.Union(readIdents, _362_recIdents); + _358_i = (_358_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("))")); isOwned = true; + isErased = true; } } else if (_source16.is_NewArray) { - Dafny.ISequence _342___mcc_h11 = _source16.dtor_dims; - Dafny.ISequence _343_dims = _342___mcc_h11; + Dafny.ISequence _363___mcc_h11 = _source16.dtor_dims; + Dafny.ISequence _364_dims = _363___mcc_h11; { - BigInteger _344_i; - _344_i = (new BigInteger((_343_dims).Count)) - (BigInteger.One); + BigInteger _365_i; + _365_i = (new BigInteger((_364_dims).Count)) - (BigInteger.One); s = Dafny.Sequence.UnicodeFromString("::std::default::Default::default()"); readIdents = Dafny.Set>.FromElements(); - while ((_344_i).Sign != -1) { - Dafny.ISequence _345_recursiveGen; - bool _346___v19; - Dafny.ISet> _347_recIdents; - Dafny.ISequence _out88; - bool _out89; - Dafny.ISet> _out90; - DCOMP.COMP.GenExpr((_343_dims).Select(_344_i), @params, true, out _out88, out _out89, out _out90); - _345_recursiveGen = _out88; - _346___v19 = _out89; - _347_recIdents = _out90; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("vec!["), s), Dafny.Sequence.UnicodeFromString("; (")), _345_recursiveGen), Dafny.Sequence.UnicodeFromString(") as usize]")); - readIdents = Dafny.Set>.Union(readIdents, _347_recIdents); - _344_i = (_344_i) - (BigInteger.One); + while ((_365_i).Sign != -1) { + Dafny.ISequence _366_recursiveGen; + bool _367___v25; + bool _368_isErased; + Dafny.ISet> _369_recIdents; + Dafny.ISequence _out104; + bool _out105; + bool _out106; + Dafny.ISet> _out107; + DCOMP.COMP.GenExpr((_364_dims).Select(_365_i), @params, true, out _out104, out _out105, out _out106, out _out107); + _366_recursiveGen = _out104; + _367___v25 = _out105; + _368_isErased = _out106; + _369_recIdents = _out107; + if (!(_368_isErased)) { + _366_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _366_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("vec!["), s), Dafny.Sequence.UnicodeFromString("; (")), _366_recursiveGen), Dafny.Sequence.UnicodeFromString(") as usize]")); + readIdents = Dafny.Set>.Union(readIdents, _369_recIdents); + _365_i = (_365_i) - (BigInteger.One); } isOwned = true; + isErased = true; } } else if (_source16.is_DatatypeValue) { - Dafny.ISequence> _348___mcc_h12 = _source16.dtor_path; - Dafny.ISequence _349___mcc_h13 = _source16.dtor_variant; - bool _350___mcc_h14 = _source16.dtor_isCo; - Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _351___mcc_h15 = _source16.dtor_contents; - Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _352_values = _351___mcc_h15; - bool _353_isCo = _350___mcc_h14; - Dafny.ISequence _354_variant = _349___mcc_h13; - Dafny.ISequence> _355_path = _348___mcc_h12; + Dafny.ISequence> _370___mcc_h12 = _source16.dtor_path; + Dafny.ISequence _371___mcc_h13 = _source16.dtor_variant; + bool _372___mcc_h14 = _source16.dtor_isCo; + Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _373___mcc_h15 = _source16.dtor_contents; + Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _374_values = _373___mcc_h15; + bool _375_isCo = _372___mcc_h14; + Dafny.ISequence _376_variant = _371___mcc_h13; + Dafny.ISequence> _377_path = _370___mcc_h12; { - Dafny.ISequence _356_path; - Dafny.ISequence _out91; - _out91 = DCOMP.COMP.GenPath(_355_path); - _356_path = _out91; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::rc::Rc::new("), _356_path), Dafny.Sequence.UnicodeFromString("::r#")), _354_variant); + Dafny.ISequence _378_path; + Dafny.ISequence _out108; + _out108 = DCOMP.COMP.GenPath(_377_path); + _378_path = _out108; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::std::rc::Rc::new("), _378_path), Dafny.Sequence.UnicodeFromString("::r#")), _376_variant); readIdents = Dafny.Set>.FromElements(); - BigInteger _357_i; - _357_i = BigInteger.Zero; + BigInteger _379_i; + _379_i = BigInteger.Zero; s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" {")); - while ((_357_i) < (new BigInteger((_352_values).Count))) { - _System._ITuple2, DAST._IExpression> _let_tmp_rhs1 = (_352_values).Select(_357_i); - Dafny.ISequence _358_name = _let_tmp_rhs1.dtor__0; - DAST._IExpression _359_value = _let_tmp_rhs1.dtor__1; - if ((_357_i).Sign == 1) { + while ((_379_i) < (new BigInteger((_374_values).Count))) { + _System._ITuple2, DAST._IExpression> _let_tmp_rhs0 = (_374_values).Select(_379_i); + Dafny.ISequence _380_name = _let_tmp_rhs0.dtor__0; + DAST._IExpression _381_value = _let_tmp_rhs0.dtor__1; + if ((_379_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - if (_353_isCo) { - Dafny.ISequence _360_recursiveGen; - bool _361___v20; - Dafny.ISet> _362_recIdents; - Dafny.ISequence _out92; - bool _out93; - Dafny.ISet> _out94; - DCOMP.COMP.GenExpr(_359_value, Dafny.Sequence>.FromElements(), true, out _out92, out _out93, out _out94); - _360_recursiveGen = _out92; - _361___v20 = _out93; - _362_recIdents = _out94; - readIdents = Dafny.Set>.Union(readIdents, _362_recIdents); - Dafny.ISequence _363_allReadCloned; - _363_allReadCloned = Dafny.Sequence.UnicodeFromString(""); - while (!(_362_recIdents).Equals(Dafny.Set>.FromElements())) { - Dafny.ISequence _364_next; - foreach (Dafny.ISequence _assign_such_that_0 in (_362_recIdents).Elements) { - _364_next = (Dafny.ISequence)_assign_such_that_0; - if ((_362_recIdents).Contains(_364_next)) { + if (_375_isCo) { + Dafny.ISequence _382_recursiveGen; + bool _383___v26; + bool _384_isErased; + Dafny.ISet> _385_recIdents; + Dafny.ISequence _out109; + bool _out110; + bool _out111; + Dafny.ISet> _out112; + DCOMP.COMP.GenExpr(_381_value, Dafny.Sequence>.FromElements(), true, out _out109, out _out110, out _out111, out _out112); + _382_recursiveGen = _out109; + _383___v26 = _out110; + _384_isErased = _out111; + _385_recIdents = _out112; + if (!(_384_isErased)) { + _382_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _382_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + _382_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _382_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + readIdents = Dafny.Set>.Union(readIdents, _385_recIdents); + Dafny.ISequence _386_allReadCloned; + _386_allReadCloned = Dafny.Sequence.UnicodeFromString(""); + while (!(_385_recIdents).Equals(Dafny.Set>.FromElements())) { + Dafny.ISequence _387_next; + foreach (Dafny.ISequence _assign_such_that_0 in (_385_recIdents).Elements) { + _387_next = (Dafny.ISequence)_assign_such_that_0; + if ((_385_recIdents).Contains(_387_next)) { goto after__ASSIGN_SUCH_THAT_0; } } - throw new System.Exception("assign-such-that search produced no value (line 900)"); + throw new System.Exception("assign-such-that search produced no value (line 985)"); after__ASSIGN_SUCH_THAT_0:; - _363_allReadCloned = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_363_allReadCloned, Dafny.Sequence.UnicodeFromString("let r#")), _364_next), Dafny.Sequence.UnicodeFromString(" = r#")), _364_next), Dafny.Sequence.UnicodeFromString(".clone();\n")); - _362_recIdents = Dafny.Set>.Difference(_362_recIdents, Dafny.Set>.FromElements(_364_next)); + _386_allReadCloned = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_386_allReadCloned, Dafny.Sequence.UnicodeFromString("let r#")), _387_next), Dafny.Sequence.UnicodeFromString(" = r#")), _387_next), Dafny.Sequence.UnicodeFromString(".clone();\n")); + _385_recIdents = Dafny.Set>.Difference(_385_recIdents, Dafny.Set>.FromElements(_387_next)); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), _358_name), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(Box::new({\n")), _363_allReadCloned), Dafny.Sequence.UnicodeFromString("move || (")), _360_recursiveGen), Dafny.Sequence.UnicodeFromString(")})))")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), _380_name), Dafny.Sequence.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(::std::boxed::Box::new({\n")), _386_allReadCloned), Dafny.Sequence.UnicodeFromString("move || (")), _382_recursiveGen), Dafny.Sequence.UnicodeFromString(")})))")); } else { - Dafny.ISequence _365_recursiveGen; - bool _366___v21; - Dafny.ISet> _367_recIdents; - Dafny.ISequence _out95; - bool _out96; - Dafny.ISet> _out97; - DCOMP.COMP.GenExpr(_359_value, @params, true, out _out95, out _out96, out _out97); - _365_recursiveGen = _out95; - _366___v21 = _out96; - _367_recIdents = _out97; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), _358_name), Dafny.Sequence.UnicodeFromString(": ")), _365_recursiveGen); - readIdents = Dafny.Set>.Union(readIdents, _367_recIdents); + Dafny.ISequence _388_recursiveGen; + bool _389___v27; + bool _390_isErased; + Dafny.ISet> _391_recIdents; + Dafny.ISequence _out113; + bool _out114; + bool _out115; + Dafny.ISet> _out116; + DCOMP.COMP.GenExpr(_381_value, @params, true, out _out113, out _out114, out _out115, out _out116); + _388_recursiveGen = _out113; + _389___v27 = _out114; + _390_isErased = _out115; + _391_recIdents = _out116; + if (!(_390_isErased)) { + _388_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _388_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + _388_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _388_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("r#")), _380_name), Dafny.Sequence.UnicodeFromString(": ")), Dafny.Sequence.UnicodeFromString("(")), _388_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + readIdents = Dafny.Set>.Union(readIdents, _391_recIdents); } - _357_i = (_357_i) + (BigInteger.One); + _379_i = (_379_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(" })")); isOwned = true; + isErased = true; } - } else if (_source16.is_NewtypeValue) { - DAST._IType _368___mcc_h16 = _source16.dtor_tpe; - DAST._IExpression _369___mcc_h17 = _source16.dtor_value; - DAST._IExpression _370_expr = _369___mcc_h17; - DAST._IType _371_tpe = _368___mcc_h16; + } else if (_source16.is_SubsetUpgrade) { + DAST._IExpression _392___mcc_h16 = _source16.dtor_value; + DAST._IType _393___mcc_h17 = _source16.dtor_typ; + DAST._IType _394_tpe = _393___mcc_h17; + DAST._IExpression _395_expr = _392___mcc_h16; { - Dafny.ISequence _372_typeString; - Dafny.ISequence _out98; - _out98 = DCOMP.COMP.GenType(_371_tpe, false, false); - _372_typeString = _out98; - Dafny.ISequence _373_recursiveGen; - bool _374___v22; - Dafny.ISet> _375_recIdents; - Dafny.ISequence _out99; - bool _out100; - Dafny.ISet> _out101; - DCOMP.COMP.GenExpr(_370_expr, @params, true, out _out99, out _out100, out _out101); - _373_recursiveGen = _out99; - _374___v22 = _out100; - _375_recIdents = _out101; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_372_typeString, Dafny.Sequence.UnicodeFromString("(")), _373_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); - isOwned = true; - readIdents = _375_recIdents; + Dafny.ISequence _396_tpeGen; + Dafny.ISequence _out117; + _out117 = DCOMP.COMP.GenType(_394_tpe, true, false); + _396_tpeGen = _out117; + Dafny.ISequence _397_recursiveGen; + bool _398_recOwned; + bool _399_recErased; + Dafny.ISet> _400_recIdents; + Dafny.ISequence _out118; + bool _out119; + bool _out120; + Dafny.ISet> _out121; + DCOMP.COMP.GenExpr(_395_expr, @params, false, out _out118, out _out119, out _out120, out _out121); + _397_recursiveGen = _out118; + _398_recOwned = _out119; + _399_recErased = _out120; + _400_recIdents = _out121; + Dafny.ISequence _401_uneraseFn; + _401_uneraseFn = ((_398_recOwned) ? (Dafny.Sequence.UnicodeFromString("unerase_owned")) : (Dafny.Sequence.UnicodeFromString("unerase"))); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("<"), _396_tpeGen), Dafny.Sequence.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _401_uneraseFn), Dafny.Sequence.UnicodeFromString("(")), _397_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + isOwned = _398_recOwned; + isErased = false; + readIdents = _400_recIdents; + } + } else if (_source16.is_SubsetDowngrade) { + DAST._IExpression _402___mcc_h18 = _source16.dtor_value; + DAST._IExpression _403_expr = _402___mcc_h18; + { + Dafny.ISequence _404_recursiveGen; + bool _405_recOwned; + bool _406_recErased; + Dafny.ISet> _407_recIdents; + Dafny.ISequence _out122; + bool _out123; + bool _out124; + Dafny.ISet> _out125; + DCOMP.COMP.GenExpr(_403_expr, @params, false, out _out122, out _out123, out _out124, out _out125); + _404_recursiveGen = _out122; + _405_recOwned = _out123; + _406_recErased = _out124; + _407_recIdents = _out125; + Dafny.ISequence _408_eraseFn; + _408_eraseFn = ((_405_recOwned) ? (Dafny.Sequence.UnicodeFromString("erase_owned")) : (Dafny.Sequence.UnicodeFromString("erase"))); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _408_eraseFn), Dafny.Sequence.UnicodeFromString("(")), _404_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + isOwned = _405_recOwned; + isErased = true; + readIdents = _407_recIdents; } } else if (_source16.is_SeqValue) { - Dafny.ISequence _376___mcc_h18 = _source16.dtor_elements; - Dafny.ISequence _377_exprs = _376___mcc_h18; + Dafny.ISequence _409___mcc_h19 = _source16.dtor_elements; + Dafny.ISequence _410_exprs = _409___mcc_h19; { - Dafny.ISequence> _378_generatedValues; - _378_generatedValues = Dafny.Sequence>.FromElements(); + Dafny.ISequence<_System._ITuple2, bool>> _411_generatedValues; + _411_generatedValues = Dafny.Sequence<_System._ITuple2, bool>>.FromElements(); readIdents = Dafny.Set>.FromElements(); - BigInteger _379_i; - _379_i = BigInteger.Zero; - while ((_379_i) < (new BigInteger((_377_exprs).Count))) { - Dafny.ISequence _380_recursiveGen; - bool _381___v23; - Dafny.ISet> _382_recIdents; - Dafny.ISequence _out102; - bool _out103; - Dafny.ISet> _out104; - DCOMP.COMP.GenExpr((_377_exprs).Select(_379_i), @params, true, out _out102, out _out103, out _out104); - _380_recursiveGen = _out102; - _381___v23 = _out103; - _382_recIdents = _out104; - _378_generatedValues = Dafny.Sequence>.Concat(_378_generatedValues, Dafny.Sequence>.FromElements(_380_recursiveGen)); - readIdents = Dafny.Set>.Union(readIdents, _382_recIdents); - _379_i = (_379_i) + (BigInteger.One); + BigInteger _412_i; + _412_i = BigInteger.Zero; + bool _413_allErased; + _413_allErased = true; + while ((_412_i) < (new BigInteger((_410_exprs).Count))) { + Dafny.ISequence _414_recursiveGen; + bool _415___v28; + bool _416_isErased; + Dafny.ISet> _417_recIdents; + Dafny.ISequence _out126; + bool _out127; + bool _out128; + Dafny.ISet> _out129; + DCOMP.COMP.GenExpr((_410_exprs).Select(_412_i), @params, true, out _out126, out _out127, out _out128, out _out129); + _414_recursiveGen = _out126; + _415___v28 = _out127; + _416_isErased = _out128; + _417_recIdents = _out129; + _413_allErased = (_413_allErased) && (_416_isErased); + _411_generatedValues = Dafny.Sequence<_System._ITuple2, bool>>.Concat(_411_generatedValues, Dafny.Sequence<_System._ITuple2, bool>>.FromElements(_System.Tuple2, bool>.create(_414_recursiveGen, _416_isErased))); + readIdents = Dafny.Set>.Union(readIdents, _417_recIdents); + _412_i = (_412_i) + (BigInteger.One); } s = Dafny.Sequence.UnicodeFromString("vec!["); - _379_i = BigInteger.Zero; - while ((_379_i) < (new BigInteger((_378_generatedValues).Count))) { - if ((_379_i).Sign == 1) { + _412_i = BigInteger.Zero; + while ((_412_i) < (new BigInteger((_411_generatedValues).Count))) { + if ((_412_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - s = Dafny.Sequence.Concat(s, (_378_generatedValues).Select(_379_i)); - _379_i = (_379_i) + (BigInteger.One); + Dafny.ISequence _418_gen; + _418_gen = ((_411_generatedValues).Select(_412_i)).dtor__0; + if ((((_411_generatedValues).Select(_412_i)).dtor__1) && (!(_413_allErased))) { + _418_gen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _418_gen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(s, _418_gen); + _412_i = (_412_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("]")); isOwned = true; + isErased = _413_allErased; } } else if (_source16.is_SetValue) { - Dafny.ISequence _383___mcc_h19 = _source16.dtor_elements; - Dafny.ISequence _384_exprs = _383___mcc_h19; + Dafny.ISequence _419___mcc_h20 = _source16.dtor_elements; + Dafny.ISequence _420_exprs = _419___mcc_h20; { - Dafny.ISequence> _385_generatedValues; - _385_generatedValues = Dafny.Sequence>.FromElements(); + Dafny.ISequence<_System._ITuple2, bool>> _421_generatedValues; + _421_generatedValues = Dafny.Sequence<_System._ITuple2, bool>>.FromElements(); readIdents = Dafny.Set>.FromElements(); - BigInteger _386_i; - _386_i = BigInteger.Zero; - while ((_386_i) < (new BigInteger((_384_exprs).Count))) { - Dafny.ISequence _387_recursiveGen; - bool _388___v24; - Dafny.ISet> _389_recIdents; - Dafny.ISequence _out105; - bool _out106; - Dafny.ISet> _out107; - DCOMP.COMP.GenExpr((_384_exprs).Select(_386_i), @params, true, out _out105, out _out106, out _out107); - _387_recursiveGen = _out105; - _388___v24 = _out106; - _389_recIdents = _out107; - _385_generatedValues = Dafny.Sequence>.Concat(_385_generatedValues, Dafny.Sequence>.FromElements(_387_recursiveGen)); - readIdents = Dafny.Set>.Union(readIdents, _389_recIdents); - _386_i = (_386_i) + (BigInteger.One); + BigInteger _422_i; + _422_i = BigInteger.Zero; + bool _423_allErased; + _423_allErased = true; + while ((_422_i) < (new BigInteger((_420_exprs).Count))) { + Dafny.ISequence _424_recursiveGen; + bool _425___v29; + bool _426_isErased; + Dafny.ISet> _427_recIdents; + Dafny.ISequence _out130; + bool _out131; + bool _out132; + Dafny.ISet> _out133; + DCOMP.COMP.GenExpr((_420_exprs).Select(_422_i), @params, true, out _out130, out _out131, out _out132, out _out133); + _424_recursiveGen = _out130; + _425___v29 = _out131; + _426_isErased = _out132; + _427_recIdents = _out133; + _423_allErased = (_423_allErased) && (_426_isErased); + _421_generatedValues = Dafny.Sequence<_System._ITuple2, bool>>.Concat(_421_generatedValues, Dafny.Sequence<_System._ITuple2, bool>>.FromElements(_System.Tuple2, bool>.create(_424_recursiveGen, _426_isErased))); + readIdents = Dafny.Set>.Union(readIdents, _427_recIdents); + _422_i = (_422_i) + (BigInteger.One); } s = Dafny.Sequence.UnicodeFromString("vec!["); - _386_i = BigInteger.Zero; - while ((_386_i) < (new BigInteger((_385_generatedValues).Count))) { - if ((_386_i).Sign == 1) { + _422_i = BigInteger.Zero; + while ((_422_i) < (new BigInteger((_421_generatedValues).Count))) { + if ((_422_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString(", ")); } - s = Dafny.Sequence.Concat(s, (_385_generatedValues).Select(_386_i)); - _386_i = (_386_i) + (BigInteger.One); + Dafny.ISequence _428_gen; + _428_gen = ((_421_generatedValues).Select(_422_i)).dtor__0; + if ((((_421_generatedValues).Select(_422_i)).dtor__1) && (!(_423_allErased))) { + _428_gen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _428_gen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(s, _428_gen); + _422_i = (_422_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("].into_iter().collect::>()")); isOwned = true; + isErased = true; } } else if (_source16.is_This) { { @@ -5423,167 +5681,234 @@ public static void GenExpr(DAST._IExpression e, Dafny.ISequence>.FromElements(Dafny.Sequence.UnicodeFromString("self")); + isErased = false; } } else if (_source16.is_Ite) { - DAST._IExpression _390___mcc_h20 = _source16.dtor_cond; - DAST._IExpression _391___mcc_h21 = _source16.dtor_thn; - DAST._IExpression _392___mcc_h22 = _source16.dtor_els; - DAST._IExpression _393_f = _392___mcc_h22; - DAST._IExpression _394_t = _391___mcc_h21; - DAST._IExpression _395_cond = _390___mcc_h20; + DAST._IExpression _429___mcc_h21 = _source16.dtor_cond; + DAST._IExpression _430___mcc_h22 = _source16.dtor_thn; + DAST._IExpression _431___mcc_h23 = _source16.dtor_els; + DAST._IExpression _432_f = _431___mcc_h23; + DAST._IExpression _433_t = _430___mcc_h22; + DAST._IExpression _434_cond = _429___mcc_h21; { - Dafny.ISequence _396_condString; - bool _397___v25; - Dafny.ISet> _398_recIdentsCond; - Dafny.ISequence _out108; - bool _out109; - Dafny.ISet> _out110; - DCOMP.COMP.GenExpr(_395_cond, @params, true, out _out108, out _out109, out _out110); - _396_condString = _out108; - _397___v25 = _out109; - _398_recIdentsCond = _out110; - Dafny.ISequence _399___v26; - bool _400_tHasToBeOwned; - Dafny.ISet> _401___v27; - Dafny.ISequence _out111; - bool _out112; - Dafny.ISet> _out113; - DCOMP.COMP.GenExpr(_394_t, @params, mustOwn, out _out111, out _out112, out _out113); - _399___v26 = _out111; - _400_tHasToBeOwned = _out112; - _401___v27 = _out113; - Dafny.ISequence _402_fString; - bool _403_fOwned; - Dafny.ISet> _404_recIdentsF; - Dafny.ISequence _out114; - bool _out115; - Dafny.ISet> _out116; - DCOMP.COMP.GenExpr(_393_f, @params, _400_tHasToBeOwned, out _out114, out _out115, out _out116); - _402_fString = _out114; - _403_fOwned = _out115; - _404_recIdentsF = _out116; - Dafny.ISequence _405_tString; - bool _406___v28; - Dafny.ISet> _407_recIdentsT; - Dafny.ISequence _out117; - bool _out118; - Dafny.ISet> _out119; - DCOMP.COMP.GenExpr(_394_t, @params, _403_fOwned, out _out117, out _out118, out _out119); - _405_tString = _out117; - _406___v28 = _out118; - _407_recIdentsT = _out119; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("(if "), _396_condString), Dafny.Sequence.UnicodeFromString(" {\n")), _405_tString), Dafny.Sequence.UnicodeFromString("\n} else {\n")), _402_fString), Dafny.Sequence.UnicodeFromString("\n})")); - isOwned = _403_fOwned; - readIdents = Dafny.Set>.Union(Dafny.Set>.Union(_398_recIdentsCond, _407_recIdentsT), _404_recIdentsF); + Dafny.ISequence _435_condString; + bool _436___v30; + bool _437_condErased; + Dafny.ISet> _438_recIdentsCond; + Dafny.ISequence _out134; + bool _out135; + bool _out136; + Dafny.ISet> _out137; + DCOMP.COMP.GenExpr(_434_cond, @params, true, out _out134, out _out135, out _out136, out _out137); + _435_condString = _out134; + _436___v30 = _out135; + _437_condErased = _out136; + _438_recIdentsCond = _out137; + if (!(_437_condErased)) { + _435_condString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _435_condString), Dafny.Sequence.UnicodeFromString(")")); + } + Dafny.ISequence _439___v31; + bool _440_tHasToBeOwned; + bool _441___v32; + Dafny.ISet> _442___v33; + Dafny.ISequence _out138; + bool _out139; + bool _out140; + Dafny.ISet> _out141; + DCOMP.COMP.GenExpr(_433_t, @params, mustOwn, out _out138, out _out139, out _out140, out _out141); + _439___v31 = _out138; + _440_tHasToBeOwned = _out139; + _441___v32 = _out140; + _442___v33 = _out141; + Dafny.ISequence _443_fString; + bool _444_fOwned; + bool _445_fErased; + Dafny.ISet> _446_recIdentsF; + Dafny.ISequence _out142; + bool _out143; + bool _out144; + Dafny.ISet> _out145; + DCOMP.COMP.GenExpr(_432_f, @params, _440_tHasToBeOwned, out _out142, out _out143, out _out144, out _out145); + _443_fString = _out142; + _444_fOwned = _out143; + _445_fErased = _out144; + _446_recIdentsF = _out145; + Dafny.ISequence _447_tString; + bool _448___v34; + bool _449_tErased; + Dafny.ISet> _450_recIdentsT; + Dafny.ISequence _out146; + bool _out147; + bool _out148; + Dafny.ISet> _out149; + DCOMP.COMP.GenExpr(_433_t, @params, _444_fOwned, out _out146, out _out147, out _out148, out _out149); + _447_tString = _out146; + _448___v34 = _out147; + _449_tErased = _out148; + _450_recIdentsT = _out149; + if ((!(_445_fErased)) || (!(_449_tErased))) { + if (_445_fErased) { + _443_fString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _443_fString), Dafny.Sequence.UnicodeFromString(")")); + } + if (_449_tErased) { + _447_tString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _447_tString), Dafny.Sequence.UnicodeFromString(")")); + } + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("(if "), _435_condString), Dafny.Sequence.UnicodeFromString(" {\n")), _447_tString), Dafny.Sequence.UnicodeFromString("\n} else {\n")), _443_fString), Dafny.Sequence.UnicodeFromString("\n})")); + isOwned = _444_fOwned; + readIdents = Dafny.Set>.Union(Dafny.Set>.Union(_438_recIdentsCond, _450_recIdentsT), _446_recIdentsF); + isErased = (_445_fErased) || (_449_tErased); } } else if (_source16.is_UnOp) { - DAST._IUnaryOp _408___mcc_h23 = _source16.dtor_unOp; - DAST._IExpression _409___mcc_h24 = _source16.dtor_expr; - DAST._IUnaryOp _source18 = _408___mcc_h23; + DAST._IUnaryOp _451___mcc_h24 = _source16.dtor_unOp; + DAST._IExpression _452___mcc_h25 = _source16.dtor_expr; + DAST._IUnaryOp _source18 = _451___mcc_h24; if (_source18.is_Not) { - DAST._IExpression _410_e = _409___mcc_h24; + DAST._IExpression _453_e = _452___mcc_h25; { - Dafny.ISequence _411_recursiveGen; - bool _412___v29; - Dafny.ISet> _413_recIdents; - Dafny.ISequence _out120; - bool _out121; - Dafny.ISet> _out122; - DCOMP.COMP.GenExpr(_410_e, @params, true, out _out120, out _out121, out _out122); - _411_recursiveGen = _out120; - _412___v29 = _out121; - _413_recIdents = _out122; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("!("), _411_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + Dafny.ISequence _454_recursiveGen; + bool _455___v35; + bool _456_recErased; + Dafny.ISet> _457_recIdents; + Dafny.ISequence _out150; + bool _out151; + bool _out152; + Dafny.ISet> _out153; + DCOMP.COMP.GenExpr(_453_e, @params, true, out _out150, out _out151, out _out152, out _out153); + _454_recursiveGen = _out150; + _455___v35 = _out151; + _456_recErased = _out152; + _457_recIdents = _out153; + if (!(_456_recErased)) { + _454_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _454_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("!("), _454_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); isOwned = true; - readIdents = _413_recIdents; + readIdents = _457_recIdents; + isErased = true; } } else if (_source18.is_BitwiseNot) { - DAST._IExpression _414_e = _409___mcc_h24; + DAST._IExpression _458_e = _452___mcc_h25; { - Dafny.ISequence _415_recursiveGen; - bool _416___v30; - Dafny.ISet> _417_recIdents; - Dafny.ISequence _out123; - bool _out124; - Dafny.ISet> _out125; - DCOMP.COMP.GenExpr(_414_e, @params, true, out _out123, out _out124, out _out125); - _415_recursiveGen = _out123; - _416___v30 = _out124; - _417_recIdents = _out125; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("~("), _415_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + Dafny.ISequence _459_recursiveGen; + bool _460___v36; + bool _461_recErased; + Dafny.ISet> _462_recIdents; + Dafny.ISequence _out154; + bool _out155; + bool _out156; + Dafny.ISet> _out157; + DCOMP.COMP.GenExpr(_458_e, @params, true, out _out154, out _out155, out _out156, out _out157); + _459_recursiveGen = _out154; + _460___v36 = _out155; + _461_recErased = _out156; + _462_recIdents = _out157; + if (!(_461_recErased)) { + _459_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _459_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("~("), _459_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); isOwned = true; - readIdents = _417_recIdents; + readIdents = _462_recIdents; + isErased = true; } } else { - DAST._IExpression _418_e = _409___mcc_h24; + DAST._IExpression _463_e = _452___mcc_h25; { - Dafny.ISequence _419_recursiveGen; - bool _420___v31; - Dafny.ISet> _421_recIdents; - Dafny.ISequence _out126; - bool _out127; - Dafny.ISet> _out128; - DCOMP.COMP.GenExpr(_418_e, @params, false, out _out126, out _out127, out _out128); - _419_recursiveGen = _out126; - _420___v31 = _out127; - _421_recIdents = _out128; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _419_recursiveGen), Dafny.Sequence.UnicodeFromString(").len()")); + Dafny.ISequence _464_recursiveGen; + bool _465___v37; + bool _466_recErased; + Dafny.ISet> _467_recIdents; + Dafny.ISequence _out158; + bool _out159; + bool _out160; + Dafny.ISet> _out161; + DCOMP.COMP.GenExpr(_463_e, @params, false, out _out158, out _out159, out _out160, out _out161); + _464_recursiveGen = _out158; + _465___v37 = _out159; + _466_recErased = _out160; + _467_recIdents = _out161; + if (!(_466_recErased)) { + _464_recursiveGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _464_recursiveGen), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _464_recursiveGen), Dafny.Sequence.UnicodeFromString(").len()")); isOwned = true; - readIdents = _421_recIdents; + readIdents = _467_recIdents; + isErased = true; } } } else if (_source16.is_BinOp) { - Dafny.ISequence _422___mcc_h25 = _source16.dtor_op; - DAST._IExpression _423___mcc_h26 = _source16.dtor_left; - DAST._IExpression _424___mcc_h27 = _source16.dtor_right; - DAST._IExpression _425_r = _424___mcc_h27; - DAST._IExpression _426_l = _423___mcc_h26; - Dafny.ISequence _427_op = _422___mcc_h25; + Dafny.ISequence _468___mcc_h26 = _source16.dtor_op; + DAST._IExpression _469___mcc_h27 = _source16.dtor_left; + DAST._IExpression _470___mcc_h28 = _source16.dtor_right; + DAST._IExpression _471_r = _470___mcc_h28; + DAST._IExpression _472_l = _469___mcc_h27; + Dafny.ISequence _473_op = _468___mcc_h26; { - Dafny.ISequence _428_left; - bool _429___v32; - Dafny.ISet> _430_recIdentsL; - Dafny.ISequence _out129; - bool _out130; - Dafny.ISet> _out131; - DCOMP.COMP.GenExpr(_426_l, @params, true, out _out129, out _out130, out _out131); - _428_left = _out129; - _429___v32 = _out130; - _430_recIdentsL = _out131; - Dafny.ISequence _431_right; - bool _432___v33; - Dafny.ISet> _433_recIdentsR; - Dafny.ISequence _out132; - bool _out133; - Dafny.ISet> _out134; - DCOMP.COMP.GenExpr(_425_r, @params, true, out _out132, out _out133, out _out134); - _431_right = _out132; - _432___v33 = _out133; - _433_recIdentsR = _out134; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _428_left), Dafny.Sequence.UnicodeFromString(" ")), _427_op), Dafny.Sequence.UnicodeFromString(" ")), _431_right), Dafny.Sequence.UnicodeFromString(")")); + Dafny.ISequence _474_left; + bool _475___v38; + bool _476_leftErased; + Dafny.ISet> _477_recIdentsL; + Dafny.ISequence _out162; + bool _out163; + bool _out164; + Dafny.ISet> _out165; + DCOMP.COMP.GenExpr(_472_l, @params, true, out _out162, out _out163, out _out164, out _out165); + _474_left = _out162; + _475___v38 = _out163; + _476_leftErased = _out164; + _477_recIdentsL = _out165; + Dafny.ISequence _478_right; + bool _479___v39; + bool _480_rightErased; + Dafny.ISet> _481_recIdentsR; + Dafny.ISequence _out166; + bool _out167; + bool _out168; + Dafny.ISet> _out169; + DCOMP.COMP.GenExpr(_471_r, @params, true, out _out166, out _out167, out _out168, out _out169); + _478_right = _out166; + _479___v39 = _out167; + _480_rightErased = _out168; + _481_recIdentsR = _out169; + if (!(_476_leftErased)) { + _474_left = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _474_left), Dafny.Sequence.UnicodeFromString(")")); + } + if (!(_480_rightErased)) { + _478_right = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _478_right), Dafny.Sequence.UnicodeFromString(")")); + } + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _474_left), Dafny.Sequence.UnicodeFromString(" ")), _473_op), Dafny.Sequence.UnicodeFromString(" ")), _478_right), Dafny.Sequence.UnicodeFromString(")")); isOwned = true; - readIdents = Dafny.Set>.Union(_430_recIdentsL, _433_recIdentsR); + readIdents = Dafny.Set>.Union(_477_recIdentsL, _481_recIdentsR); + isErased = true; } } else if (_source16.is_Select) { - DAST._IExpression _434___mcc_h28 = _source16.dtor_expr; - Dafny.ISequence _435___mcc_h29 = _source16.dtor_field; - bool _436___mcc_h30 = _source16.dtor_onDatatype; - bool _437_isDatatype = _436___mcc_h30; - Dafny.ISequence _438_field = _435___mcc_h29; - DAST._IExpression _439_on = _434___mcc_h28; + DAST._IExpression _482___mcc_h29 = _source16.dtor_expr; + Dafny.ISequence _483___mcc_h30 = _source16.dtor_field; + bool _484___mcc_h31 = _source16.dtor_onDatatype; + bool _485_isDatatype = _484___mcc_h31; + Dafny.ISequence _486_field = _483___mcc_h30; + DAST._IExpression _487_on = _482___mcc_h29; { - Dafny.ISequence _440_onString; - bool _441___v34; - Dafny.ISet> _442_recIdents; - Dafny.ISequence _out135; - bool _out136; - Dafny.ISet> _out137; - DCOMP.COMP.GenExpr(_439_on, @params, false, out _out135, out _out136, out _out137); - _440_onString = _out135; - _441___v34 = _out136; - _442_recIdents = _out137; - if (_437_isDatatype) { - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _440_onString), Dafny.Sequence.UnicodeFromString(")")), Dafny.Sequence.UnicodeFromString(".r#")), _438_field), Dafny.Sequence.UnicodeFromString("()")); + Dafny.ISequence _488_onString; + bool _489_onOwned; + bool _490_onErased; + Dafny.ISet> _491_recIdents; + Dafny.ISequence _out170; + bool _out171; + bool _out172; + Dafny.ISet> _out173; + DCOMP.COMP.GenExpr(_487_on, @params, false, out _out170, out _out171, out _out172, out _out173); + _488_onString = _out170; + _489_onOwned = _out171; + _490_onErased = _out172; + _491_recIdents = _out173; + if (!(_490_onErased)) { + Dafny.ISequence _492_eraseFn; + _492_eraseFn = ((_489_onOwned) ? (Dafny.Sequence.UnicodeFromString("erase_owned")) : (Dafny.Sequence.UnicodeFromString("erase"))); + _488_onString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _492_eraseFn), Dafny.Sequence.UnicodeFromString("(")), _488_onString), Dafny.Sequence.UnicodeFromString(")")); + } + if (_485_isDatatype) { + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _488_onString), Dafny.Sequence.UnicodeFromString(")")), Dafny.Sequence.UnicodeFromString(".r#")), _486_field), Dafny.Sequence.UnicodeFromString("()")); if (mustOwn) { s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), s), Dafny.Sequence.UnicodeFromString(").clone()")); isOwned = true; @@ -5591,7 +5916,7 @@ public static void GenExpr(DAST._IExpression e, Dafny.ISequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _440_onString), Dafny.Sequence.UnicodeFromString(")")), Dafny.Sequence.UnicodeFromString(".r#")), _438_field); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _488_onString), Dafny.Sequence.UnicodeFromString(")")), Dafny.Sequence.UnicodeFromString(".r#")), _486_field); if (mustOwn) { s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), s), Dafny.Sequence.UnicodeFromString(").clone()")); isOwned = true; @@ -5599,72 +5924,80 @@ public static void GenExpr(DAST._IExpression e, Dafny.ISequence _444___mcc_h32 = _source16.dtor_field; - bool _445___mcc_h33 = _source16.dtor_onDatatype; - bool _446___mcc_h34 = _source16.dtor_isStatic; - BigInteger _447___mcc_h35 = _source16.dtor_arity; - BigInteger _448_arity = _447___mcc_h35; - bool _449_isStatic = _446___mcc_h34; - bool _450_isDatatype = _445___mcc_h33; - Dafny.ISequence _451_field = _444___mcc_h32; - DAST._IExpression _452_on = _443___mcc_h31; + DAST._IExpression _493___mcc_h32 = _source16.dtor_expr; + Dafny.ISequence _494___mcc_h33 = _source16.dtor_field; + bool _495___mcc_h34 = _source16.dtor_onDatatype; + bool _496___mcc_h35 = _source16.dtor_isStatic; + BigInteger _497___mcc_h36 = _source16.dtor_arity; + BigInteger _498_arity = _497___mcc_h36; + bool _499_isStatic = _496___mcc_h35; + bool _500_isDatatype = _495___mcc_h34; + Dafny.ISequence _501_field = _494___mcc_h33; + DAST._IExpression _502_on = _493___mcc_h32; { - Dafny.ISequence _453_onString; - bool _454_onOwned; - Dafny.ISet> _455_recIdents; - Dafny.ISequence _out138; - bool _out139; - Dafny.ISet> _out140; - DCOMP.COMP.GenExpr(_452_on, @params, false, out _out138, out _out139, out _out140); - _453_onString = _out138; - _454_onOwned = _out139; - _455_recIdents = _out140; - if (_449_isStatic) { - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_453_onString, Dafny.Sequence.UnicodeFromString("::")), _451_field); + Dafny.ISequence _503_onString; + bool _504_onOwned; + bool _505___v40; + Dafny.ISet> _506_recIdents; + Dafny.ISequence _out174; + bool _out175; + bool _out176; + Dafny.ISet> _out177; + DCOMP.COMP.GenExpr(_502_on, @params, false, out _out174, out _out175, out _out176, out _out177); + _503_onString = _out174; + _504_onOwned = _out175; + _505___v40 = _out176; + _506_recIdents = _out177; + if (_499_isStatic) { + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_503_onString, Dafny.Sequence.UnicodeFromString("::")), _501_field); } else { s = Dafny.Sequence.UnicodeFromString("{\n"); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("let callTarget = (")), _453_onString), ((_454_onOwned) ? (Dafny.Sequence.UnicodeFromString(")")) : (Dafny.Sequence.UnicodeFromString(").clone()")))), Dafny.Sequence.UnicodeFromString(";\n")); - Dafny.ISequence _456_args; - _456_args = Dafny.Sequence.UnicodeFromString(""); - BigInteger _457_i; - _457_i = BigInteger.Zero; - while ((_457_i) < (_448_arity)) { - if ((_457_i).Sign == 1) { - _456_args = Dafny.Sequence.Concat(_456_args, Dafny.Sequence.UnicodeFromString(", ")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("let callTarget = (")), _503_onString), ((_504_onOwned) ? (Dafny.Sequence.UnicodeFromString(")")) : (Dafny.Sequence.UnicodeFromString(").clone()")))), Dafny.Sequence.UnicodeFromString(";\n")); + Dafny.ISequence _507_args; + _507_args = Dafny.Sequence.UnicodeFromString(""); + BigInteger _508_i; + _508_i = BigInteger.Zero; + while ((_508_i) < (_498_arity)) { + if ((_508_i).Sign == 1) { + _507_args = Dafny.Sequence.Concat(_507_args, Dafny.Sequence.UnicodeFromString(", ")); } - _456_args = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_456_args, Dafny.Sequence.UnicodeFromString("arg")), DCOMP.__default.natToString(_457_i)); - _457_i = (_457_i) + (BigInteger.One); + _507_args = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_507_args, Dafny.Sequence.UnicodeFromString("arg")), DCOMP.__default.natToString(_508_i)); + _508_i = (_508_i) + (BigInteger.One); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("move |")), _456_args), Dafny.Sequence.UnicodeFromString("| {\n")); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("callTarget.")), _451_field), Dafny.Sequence.UnicodeFromString("(")), _456_args), Dafny.Sequence.UnicodeFromString(")\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("move |")), _507_args), Dafny.Sequence.UnicodeFromString("| {\n")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("callTarget.")), _501_field), Dafny.Sequence.UnicodeFromString("(")), _507_args), Dafny.Sequence.UnicodeFromString(")\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}\n")); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("}")); } s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::FunctionWrapper("), s), Dafny.Sequence.UnicodeFromString(")")); isOwned = true; - readIdents = _455_recIdents; + isErased = true; + readIdents = _506_recIdents; } } else if (_source16.is_TupleSelect) { - DAST._IExpression _458___mcc_h36 = _source16.dtor_expr; - BigInteger _459___mcc_h37 = _source16.dtor_index; - BigInteger _460_idx = _459___mcc_h37; - DAST._IExpression _461_on = _458___mcc_h36; + DAST._IExpression _509___mcc_h37 = _source16.dtor_expr; + BigInteger _510___mcc_h38 = _source16.dtor_index; + BigInteger _511_idx = _510___mcc_h38; + DAST._IExpression _512_on = _509___mcc_h37; { - Dafny.ISequence _462_onString; - bool _463___v35; - Dafny.ISet> _464_recIdents; - Dafny.ISequence _out141; - bool _out142; - Dafny.ISet> _out143; - DCOMP.COMP.GenExpr(_461_on, @params, false, out _out141, out _out142, out _out143); - _462_onString = _out141; - _463___v35 = _out142; - _464_recIdents = _out143; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _462_onString), Dafny.Sequence.UnicodeFromString(").")), DCOMP.__default.natToString(_460_idx)); + Dafny.ISequence _513_onString; + bool _514___v41; + bool _515_tupErased; + Dafny.ISet> _516_recIdents; + Dafny.ISequence _out178; + bool _out179; + bool _out180; + Dafny.ISet> _out181; + DCOMP.COMP.GenExpr(_512_on, @params, false, out _out178, out _out179, out _out180, out _out181); + _513_onString = _out178; + _514___v41 = _out179; + _515_tupErased = _out180; + _516_recIdents = _out181; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _513_onString), Dafny.Sequence.UnicodeFromString(").")), DCOMP.__default.natToString(_511_idx)); if (mustOwn) { s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), s), Dafny.Sequence.UnicodeFromString(")")), Dafny.Sequence.UnicodeFromString(".clone()")); isOwned = true; @@ -5672,387 +6005,444 @@ public static void GenExpr(DAST._IExpression e, Dafny.ISequence.Concat(Dafny.Sequence.UnicodeFromString("&"), s); isOwned = false; } - readIdents = _464_recIdents; + isErased = _515_tupErased; + readIdents = _516_recIdents; } } else if (_source16.is_Call) { - DAST._IExpression _465___mcc_h38 = _source16.dtor_on; - Dafny.ISequence _466___mcc_h39 = _source16.dtor_name; - Dafny.ISequence _467___mcc_h40 = _source16.dtor_typeArgs; - Dafny.ISequence _468___mcc_h41 = _source16.dtor_args; - Dafny.ISequence _469_args = _468___mcc_h41; - Dafny.ISequence _470_typeArgs = _467___mcc_h40; - Dafny.ISequence _471_name = _466___mcc_h39; - DAST._IExpression _472_on = _465___mcc_h38; + DAST._IExpression _517___mcc_h39 = _source16.dtor_on; + Dafny.ISequence _518___mcc_h40 = _source16.dtor_name; + Dafny.ISequence _519___mcc_h41 = _source16.dtor_typeArgs; + Dafny.ISequence _520___mcc_h42 = _source16.dtor_args; + Dafny.ISequence _521_args = _520___mcc_h42; + Dafny.ISequence _522_typeArgs = _519___mcc_h41; + Dafny.ISequence _523_name = _518___mcc_h40; + DAST._IExpression _524_on = _517___mcc_h39; { readIdents = Dafny.Set>.FromElements(); - Dafny.ISequence _473_typeArgString; - _473_typeArgString = Dafny.Sequence.UnicodeFromString(""); - if ((new BigInteger((_470_typeArgs).Count)) >= (BigInteger.One)) { - BigInteger _474_typeI; - _474_typeI = BigInteger.Zero; - _473_typeArgString = Dafny.Sequence.UnicodeFromString("::<"); - while ((_474_typeI) < (new BigInteger((_470_typeArgs).Count))) { - if ((_474_typeI).Sign == 1) { - _473_typeArgString = Dafny.Sequence.Concat(_473_typeArgString, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _525_typeArgString; + _525_typeArgString = Dafny.Sequence.UnicodeFromString(""); + if ((new BigInteger((_522_typeArgs).Count)) >= (BigInteger.One)) { + BigInteger _526_typeI; + _526_typeI = BigInteger.Zero; + _525_typeArgString = Dafny.Sequence.UnicodeFromString("::<"); + while ((_526_typeI) < (new BigInteger((_522_typeArgs).Count))) { + if ((_526_typeI).Sign == 1) { + _525_typeArgString = Dafny.Sequence.Concat(_525_typeArgString, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _475_typeString; - Dafny.ISequence _out144; - _out144 = DCOMP.COMP.GenType((_470_typeArgs).Select(_474_typeI), false, false); - _475_typeString = _out144; - _473_typeArgString = Dafny.Sequence.Concat(_473_typeArgString, _475_typeString); - _474_typeI = (_474_typeI) + (BigInteger.One); + Dafny.ISequence _527_typeString; + Dafny.ISequence _out182; + _out182 = DCOMP.COMP.GenType((_522_typeArgs).Select(_526_typeI), false, false); + _527_typeString = _out182; + _525_typeArgString = Dafny.Sequence.Concat(_525_typeArgString, _527_typeString); + _526_typeI = (_526_typeI) + (BigInteger.One); } - _473_typeArgString = Dafny.Sequence.Concat(_473_typeArgString, Dafny.Sequence.UnicodeFromString(">")); + _525_typeArgString = Dafny.Sequence.Concat(_525_typeArgString, Dafny.Sequence.UnicodeFromString(">")); } - Dafny.ISequence _476_argString; - _476_argString = Dafny.Sequence.UnicodeFromString(""); - BigInteger _477_i; - _477_i = BigInteger.Zero; - while ((_477_i) < (new BigInteger((_469_args).Count))) { - if ((_477_i).Sign == 1) { - _476_argString = Dafny.Sequence.Concat(_476_argString, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _528_argString; + _528_argString = Dafny.Sequence.UnicodeFromString(""); + BigInteger _529_i; + _529_i = BigInteger.Zero; + while ((_529_i) < (new BigInteger((_521_args).Count))) { + if ((_529_i).Sign == 1) { + _528_argString = Dafny.Sequence.Concat(_528_argString, Dafny.Sequence.UnicodeFromString(", ")); + } + Dafny.ISequence _530_argExpr; + bool _531_isOwned; + bool _532_argErased; + Dafny.ISet> _533_argIdents; + Dafny.ISequence _out183; + bool _out184; + bool _out185; + Dafny.ISet> _out186; + DCOMP.COMP.GenExpr((_521_args).Select(_529_i), @params, false, out _out183, out _out184, out _out185, out _out186); + _530_argExpr = _out183; + _531_isOwned = _out184; + _532_argErased = _out185; + _533_argIdents = _out186; + if (_531_isOwned) { + _530_argExpr = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("&"), _530_argExpr); } - Dafny.ISequence _478_argExpr; - bool _479_isOwned; - Dafny.ISet> _480_recIdents; - Dafny.ISequence _out145; - bool _out146; - Dafny.ISet> _out147; - DCOMP.COMP.GenExpr((_469_args).Select(_477_i), @params, false, out _out145, out _out146, out _out147); - _478_argExpr = _out145; - _479_isOwned = _out146; - _480_recIdents = _out147; - readIdents = Dafny.Set>.Union(readIdents, _480_recIdents); - _476_argString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_476_argString, ((_479_isOwned) ? (Dafny.Sequence.UnicodeFromString("&")) : (Dafny.Sequence.UnicodeFromString("")))), _478_argExpr); - _477_i = (_477_i) + (BigInteger.One); + _528_argString = Dafny.Sequence.Concat(_528_argString, _530_argExpr); + readIdents = Dafny.Set>.Union(readIdents, _533_argIdents); + _529_i = (_529_i) + (BigInteger.One); } - Dafny.ISequence _481_enclosingString; - bool _482___v36; - Dafny.ISet> _483_recIdents; - Dafny.ISequence _out148; - bool _out149; - Dafny.ISet> _out150; - DCOMP.COMP.GenExpr(_472_on, @params, false, out _out148, out _out149, out _out150); - _481_enclosingString = _out148; - _482___v36 = _out149; - _483_recIdents = _out150; - readIdents = Dafny.Set>.Union(readIdents, _483_recIdents); - DAST._IExpression _source19 = _472_on; + Dafny.ISequence _534_enclosingString; + bool _535___v42; + bool _536___v43; + Dafny.ISet> _537_recIdents; + Dafny.ISequence _out187; + bool _out188; + bool _out189; + Dafny.ISet> _out190; + DCOMP.COMP.GenExpr(_524_on, @params, false, out _out187, out _out188, out _out189, out _out190); + _534_enclosingString = _out187; + _535___v42 = _out188; + _536___v43 = _out189; + _537_recIdents = _out190; + readIdents = Dafny.Set>.Union(readIdents, _537_recIdents); + DAST._IExpression _source19 = _524_on; if (_source19.is_Literal) { - DAST._ILiteral _484___mcc_h54 = _source19.dtor_Literal_a0; + DAST._ILiteral _538___mcc_h56 = _source19.dtor_Literal_a0; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Ident) { - Dafny.ISequence _485___mcc_h56 = _source19.dtor_Ident_a0; + Dafny.ISequence _539___mcc_h58 = _source19.dtor_Ident_a0; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Companion) { - Dafny.ISequence> _486___mcc_h58 = _source19.dtor_Companion_a0; + Dafny.ISequence> _540___mcc_h60 = _source19.dtor_Companion_a0; { - _481_enclosingString = Dafny.Sequence.Concat(_481_enclosingString, Dafny.Sequence.UnicodeFromString("::")); + _534_enclosingString = Dafny.Sequence.Concat(_534_enclosingString, Dafny.Sequence.UnicodeFromString("::")); } } else if (_source19.is_Tuple) { - Dafny.ISequence _487___mcc_h60 = _source19.dtor_Tuple_a0; + Dafny.ISequence _541___mcc_h62 = _source19.dtor_Tuple_a0; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_New) { - Dafny.ISequence> _488___mcc_h62 = _source19.dtor_path; - Dafny.ISequence _489___mcc_h63 = _source19.dtor_args; + Dafny.ISequence> _542___mcc_h64 = _source19.dtor_path; + Dafny.ISequence _543___mcc_h65 = _source19.dtor_args; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_NewArray) { - Dafny.ISequence _490___mcc_h66 = _source19.dtor_dims; + Dafny.ISequence _544___mcc_h68 = _source19.dtor_dims; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_DatatypeValue) { - Dafny.ISequence> _491___mcc_h68 = _source19.dtor_path; - Dafny.ISequence _492___mcc_h69 = _source19.dtor_variant; - bool _493___mcc_h70 = _source19.dtor_isCo; - Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _494___mcc_h71 = _source19.dtor_contents; + Dafny.ISequence> _545___mcc_h70 = _source19.dtor_path; + Dafny.ISequence _546___mcc_h71 = _source19.dtor_variant; + bool _547___mcc_h72 = _source19.dtor_isCo; + Dafny.ISequence<_System._ITuple2, DAST._IExpression>> _548___mcc_h73 = _source19.dtor_contents; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } - } else if (_source19.is_NewtypeValue) { - DAST._IType _495___mcc_h76 = _source19.dtor_tpe; - DAST._IExpression _496___mcc_h77 = _source19.dtor_value; + } else if (_source19.is_SubsetUpgrade) { + DAST._IExpression _549___mcc_h78 = _source19.dtor_value; + DAST._IType _550___mcc_h79 = _source19.dtor_typ; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + } + } else if (_source19.is_SubsetDowngrade) { + DAST._IExpression _551___mcc_h82 = _source19.dtor_value; + { + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_SeqValue) { - Dafny.ISequence _497___mcc_h80 = _source19.dtor_elements; + Dafny.ISequence _552___mcc_h84 = _source19.dtor_elements; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_SetValue) { - Dafny.ISequence _498___mcc_h82 = _source19.dtor_elements; + Dafny.ISequence _553___mcc_h86 = _source19.dtor_elements; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_This) { { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Ite) { - DAST._IExpression _499___mcc_h84 = _source19.dtor_cond; - DAST._IExpression _500___mcc_h85 = _source19.dtor_thn; - DAST._IExpression _501___mcc_h86 = _source19.dtor_els; + DAST._IExpression _554___mcc_h88 = _source19.dtor_cond; + DAST._IExpression _555___mcc_h89 = _source19.dtor_thn; + DAST._IExpression _556___mcc_h90 = _source19.dtor_els; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_UnOp) { - DAST._IUnaryOp _502___mcc_h90 = _source19.dtor_unOp; - DAST._IExpression _503___mcc_h91 = _source19.dtor_expr; + DAST._IUnaryOp _557___mcc_h94 = _source19.dtor_unOp; + DAST._IExpression _558___mcc_h95 = _source19.dtor_expr; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_BinOp) { - Dafny.ISequence _504___mcc_h94 = _source19.dtor_op; - DAST._IExpression _505___mcc_h95 = _source19.dtor_left; - DAST._IExpression _506___mcc_h96 = _source19.dtor_right; + Dafny.ISequence _559___mcc_h98 = _source19.dtor_op; + DAST._IExpression _560___mcc_h99 = _source19.dtor_left; + DAST._IExpression _561___mcc_h100 = _source19.dtor_right; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Select) { - DAST._IExpression _507___mcc_h100 = _source19.dtor_expr; - Dafny.ISequence _508___mcc_h101 = _source19.dtor_field; - bool _509___mcc_h102 = _source19.dtor_onDatatype; + DAST._IExpression _562___mcc_h104 = _source19.dtor_expr; + Dafny.ISequence _563___mcc_h105 = _source19.dtor_field; + bool _564___mcc_h106 = _source19.dtor_onDatatype; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_SelectFn) { - DAST._IExpression _510___mcc_h106 = _source19.dtor_expr; - Dafny.ISequence _511___mcc_h107 = _source19.dtor_field; - bool _512___mcc_h108 = _source19.dtor_onDatatype; - bool _513___mcc_h109 = _source19.dtor_isStatic; - BigInteger _514___mcc_h110 = _source19.dtor_arity; + DAST._IExpression _565___mcc_h110 = _source19.dtor_expr; + Dafny.ISequence _566___mcc_h111 = _source19.dtor_field; + bool _567___mcc_h112 = _source19.dtor_onDatatype; + bool _568___mcc_h113 = _source19.dtor_isStatic; + BigInteger _569___mcc_h114 = _source19.dtor_arity; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_TupleSelect) { - DAST._IExpression _515___mcc_h116 = _source19.dtor_expr; - BigInteger _516___mcc_h117 = _source19.dtor_index; + DAST._IExpression _570___mcc_h120 = _source19.dtor_expr; + BigInteger _571___mcc_h121 = _source19.dtor_index; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Call) { - DAST._IExpression _517___mcc_h120 = _source19.dtor_on; - Dafny.ISequence _518___mcc_h121 = _source19.dtor_name; - Dafny.ISequence _519___mcc_h122 = _source19.dtor_typeArgs; - Dafny.ISequence _520___mcc_h123 = _source19.dtor_args; + DAST._IExpression _572___mcc_h124 = _source19.dtor_on; + Dafny.ISequence _573___mcc_h125 = _source19.dtor_name; + Dafny.ISequence _574___mcc_h126 = _source19.dtor_typeArgs; + Dafny.ISequence _575___mcc_h127 = _source19.dtor_args; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Lambda) { - Dafny.ISequence _521___mcc_h128 = _source19.dtor_params; - Dafny.ISequence _522___mcc_h129 = _source19.dtor_body; + Dafny.ISequence _576___mcc_h132 = _source19.dtor_params; + DAST._IType _577___mcc_h133 = _source19.dtor_retType; + Dafny.ISequence _578___mcc_h134 = _source19.dtor_body; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_IIFE) { - Dafny.ISequence _523___mcc_h132 = _source19.dtor_name; - DAST._IType _524___mcc_h133 = _source19.dtor_typ; - DAST._IExpression _525___mcc_h134 = _source19.dtor_value; - DAST._IExpression _526___mcc_h135 = _source19.dtor_iifeBody; + Dafny.ISequence _579___mcc_h138 = _source19.dtor_name; + DAST._IType _580___mcc_h139 = _source19.dtor_typ; + DAST._IExpression _581___mcc_h140 = _source19.dtor_value; + DAST._IExpression _582___mcc_h141 = _source19.dtor_iifeBody; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_Apply) { - DAST._IExpression _527___mcc_h140 = _source19.dtor_expr; - Dafny.ISequence _528___mcc_h141 = _source19.dtor_args; + DAST._IExpression _583___mcc_h146 = _source19.dtor_expr; + Dafny.ISequence _584___mcc_h147 = _source19.dtor_args; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else if (_source19.is_TypeTest) { - DAST._IExpression _529___mcc_h144 = _source19.dtor_on; - Dafny.ISequence> _530___mcc_h145 = _source19.dtor_dType; - Dafny.ISequence _531___mcc_h146 = _source19.dtor_variant; + DAST._IExpression _585___mcc_h150 = _source19.dtor_on; + Dafny.ISequence> _586___mcc_h151 = _source19.dtor_dType; + Dafny.ISequence _587___mcc_h152 = _source19.dtor_variant; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } else { - DAST._IType _532___mcc_h150 = _source19.dtor_typ; + DAST._IType _588___mcc_h156 = _source19.dtor_typ; { - _481_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _481_enclosingString), Dafny.Sequence.UnicodeFromString(").")); + _534_enclosingString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("("), _534_enclosingString), Dafny.Sequence.UnicodeFromString(").")); } } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_481_enclosingString, Dafny.Sequence.UnicodeFromString("r#")), (_471_name)), _473_typeArgString), Dafny.Sequence.UnicodeFromString("(")), _476_argString), Dafny.Sequence.UnicodeFromString(")")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_534_enclosingString, Dafny.Sequence.UnicodeFromString("r#")), (_523_name)), _525_typeArgString), Dafny.Sequence.UnicodeFromString("(")), _528_argString), Dafny.Sequence.UnicodeFromString(")")); isOwned = true; + isErased = false; } } else if (_source16.is_Lambda) { - Dafny.ISequence _533___mcc_h42 = _source16.dtor_params; - Dafny.ISequence _534___mcc_h43 = _source16.dtor_body; - Dafny.ISequence _535_body = _534___mcc_h43; - Dafny.ISequence _536_params = _533___mcc_h42; + Dafny.ISequence _589___mcc_h43 = _source16.dtor_params; + DAST._IType _590___mcc_h44 = _source16.dtor_retType; + Dafny.ISequence _591___mcc_h45 = _source16.dtor_body; + Dafny.ISequence _592_body = _591___mcc_h45; + DAST._IType _593_retType = _590___mcc_h44; + Dafny.ISequence _594_params = _589___mcc_h43; { - Dafny.ISequence> _537_paramNames; - _537_paramNames = Dafny.Sequence>.FromElements(); - BigInteger _538_i; - _538_i = BigInteger.Zero; - while ((_538_i) < (new BigInteger((_536_params).Count))) { - _537_paramNames = Dafny.Sequence>.Concat(_537_paramNames, Dafny.Sequence>.FromElements(((_536_params).Select(_538_i)).dtor_name)); - _538_i = (_538_i) + (BigInteger.One); + Dafny.ISequence> _595_paramNames; + _595_paramNames = Dafny.Sequence>.FromElements(); + BigInteger _596_i; + _596_i = BigInteger.Zero; + while ((_596_i) < (new BigInteger((_594_params).Count))) { + _595_paramNames = Dafny.Sequence>.Concat(_595_paramNames, Dafny.Sequence>.FromElements(((_594_params).Select(_596_i)).dtor_name)); + _596_i = (_596_i) + (BigInteger.One); } - Dafny.ISequence _539_recursiveGen; - Dafny.ISet> _540_recIdents; - Dafny.ISequence _out151; - Dafny.ISet> _out152; - DCOMP.COMP.GenStmts(_535_body, _537_paramNames, Dafny.Sequence.UnicodeFromString(""), out _out151, out _out152); - _539_recursiveGen = _out151; - _540_recIdents = _out152; + Dafny.ISequence _597_recursiveGen; + Dafny.ISet> _598_recIdents; + Dafny.ISequence _out191; + Dafny.ISet> _out192; + DCOMP.COMP.GenStmts(_592_body, _595_paramNames, true, Dafny.Sequence.UnicodeFromString(""), out _out191, out _out192); + _597_recursiveGen = _out191; + _598_recIdents = _out192; readIdents = Dafny.Set>.FromElements(); - Dafny.ISequence _541_allReadCloned; - _541_allReadCloned = Dafny.Sequence.UnicodeFromString(""); - while (!(_540_recIdents).Equals(Dafny.Set>.FromElements())) { - Dafny.ISequence _542_next; - foreach (Dafny.ISequence _assign_such_that_1 in (_540_recIdents).Elements) { - _542_next = (Dafny.ISequence)_assign_such_that_1; - if ((_540_recIdents).Contains(_542_next)) { + Dafny.ISequence _599_allReadCloned; + _599_allReadCloned = Dafny.Sequence.UnicodeFromString(""); + while (!(_598_recIdents).Equals(Dafny.Set>.FromElements())) { + Dafny.ISequence _600_next; + foreach (Dafny.ISequence _assign_such_that_1 in (_598_recIdents).Elements) { + _600_next = (Dafny.ISequence)_assign_such_that_1; + if ((_598_recIdents).Contains(_600_next)) { goto after__ASSIGN_SUCH_THAT_1; } } - throw new System.Exception("assign-such-that search produced no value (line 1138)"); + throw new System.Exception("assign-such-that search produced no value (line 1313)"); after__ASSIGN_SUCH_THAT_1:; - if (!((_537_paramNames).Contains(_542_next))) { - _541_allReadCloned = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_541_allReadCloned, Dafny.Sequence.UnicodeFromString("let r#")), _542_next), Dafny.Sequence.UnicodeFromString(" = r#")), _542_next), Dafny.Sequence.UnicodeFromString(".clone();\n")); - readIdents = Dafny.Set>.Union(readIdents, Dafny.Set>.FromElements(_542_next)); + if (!((_595_paramNames).Contains(_600_next))) { + _599_allReadCloned = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_599_allReadCloned, Dafny.Sequence.UnicodeFromString("let r#")), _600_next), Dafny.Sequence.UnicodeFromString(" = r#")), _600_next), Dafny.Sequence.UnicodeFromString(".clone();\n")); + readIdents = Dafny.Set>.Union(readIdents, Dafny.Set>.FromElements(_600_next)); } - _540_recIdents = Dafny.Set>.Difference(_540_recIdents, Dafny.Set>.FromElements(_542_next)); + _598_recIdents = Dafny.Set>.Difference(_598_recIdents, Dafny.Set>.FromElements(_600_next)); } - Dafny.ISequence _543_paramsString; - _543_paramsString = Dafny.Sequence.UnicodeFromString(""); - _538_i = BigInteger.Zero; - while ((_538_i) < (new BigInteger((_536_params).Count))) { - if ((_538_i).Sign == 1) { - _543_paramsString = Dafny.Sequence.Concat(_543_paramsString, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _601_paramsString; + _601_paramsString = Dafny.Sequence.UnicodeFromString(""); + _596_i = BigInteger.Zero; + while ((_596_i) < (new BigInteger((_594_params).Count))) { + if ((_596_i).Sign == 1) { + _601_paramsString = Dafny.Sequence.Concat(_601_paramsString, Dafny.Sequence.UnicodeFromString(", ")); } - Dafny.ISequence _544_typStr; - Dafny.ISequence _out153; - _out153 = DCOMP.COMP.GenType(((_536_params).Select(_538_i)).dtor_typ, false, true); - _544_typStr = _out153; - _543_paramsString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_543_paramsString, ((_536_params).Select(_538_i)).dtor_name), Dafny.Sequence.UnicodeFromString(": &")), _544_typStr); - _538_i = (_538_i) + (BigInteger.One); + Dafny.ISequence _602_typStr; + Dafny.ISequence _out193; + _out193 = DCOMP.COMP.GenType(((_594_params).Select(_596_i)).dtor_typ, false, true); + _602_typStr = _out193; + _601_paramsString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(_601_paramsString, ((_594_params).Select(_596_i)).dtor_name), Dafny.Sequence.UnicodeFromString(": &")), _602_typStr); + _596_i = (_596_i) + (BigInteger.One); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::FunctionWrapper({\n"), _541_allReadCloned), Dafny.Sequence.UnicodeFromString("Box::new(move |")), _543_paramsString), Dafny.Sequence.UnicodeFromString("| {\n")), _539_recursiveGen), Dafny.Sequence.UnicodeFromString("\n})})")); + Dafny.ISequence _603_retTypeGen; + Dafny.ISequence _out194; + _out194 = DCOMP.COMP.GenType(_593_retType, false, true); + _603_retTypeGen = _out194; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::FunctionWrapper({\n"), _599_allReadCloned), Dafny.Sequence.UnicodeFromString("::std::boxed::Box::new(move |")), _601_paramsString), Dafny.Sequence.UnicodeFromString("| -> ")), _603_retTypeGen), Dafny.Sequence.UnicodeFromString(" {\n")), _597_recursiveGen), Dafny.Sequence.UnicodeFromString("\n})})")); isOwned = true; + isErased = true; } } else if (_source16.is_IIFE) { - Dafny.ISequence _545___mcc_h44 = _source16.dtor_name; - DAST._IType _546___mcc_h45 = _source16.dtor_typ; - DAST._IExpression _547___mcc_h46 = _source16.dtor_value; - DAST._IExpression _548___mcc_h47 = _source16.dtor_iifeBody; - DAST._IExpression _549_iifeBody = _548___mcc_h47; - DAST._IExpression _550_value = _547___mcc_h46; - DAST._IType _551_tpe = _546___mcc_h45; - Dafny.ISequence _552_name = _545___mcc_h44; + Dafny.ISequence _604___mcc_h46 = _source16.dtor_name; + DAST._IType _605___mcc_h47 = _source16.dtor_typ; + DAST._IExpression _606___mcc_h48 = _source16.dtor_value; + DAST._IExpression _607___mcc_h49 = _source16.dtor_iifeBody; + DAST._IExpression _608_iifeBody = _607___mcc_h49; + DAST._IExpression _609_value = _606___mcc_h48; + DAST._IType _610_tpe = _605___mcc_h47; + Dafny.ISequence _611_name = _604___mcc_h46; { - Dafny.ISequence _553_valueGen; - bool _554_valueOwned; - Dafny.ISet> _555_recIdents; - Dafny.ISequence _out154; - bool _out155; - Dafny.ISet> _out156; - DCOMP.COMP.GenExpr(_550_value, @params, false, out _out154, out _out155, out _out156); - _553_valueGen = _out154; - _554_valueOwned = _out155; - _555_recIdents = _out156; - readIdents = _555_recIdents; - Dafny.ISequence _556_valueTypeGen; - Dafny.ISequence _out157; - _out157 = DCOMP.COMP.GenType(_551_tpe, false, true); - _556_valueTypeGen = _out157; - Dafny.ISequence _557_bodyGen; - bool _558_bodyOwned; - Dafny.ISet> _559_bodyIdents; - Dafny.ISequence _out158; - bool _out159; - Dafny.ISet> _out160; - DCOMP.COMP.GenExpr(_549_iifeBody, Dafny.Sequence>.Concat(@params, ((_554_valueOwned) ? (Dafny.Sequence>.FromElements()) : (Dafny.Sequence>.FromElements((_552_name))))), mustOwn, out _out158, out _out159, out _out160); - _557_bodyGen = _out158; - _558_bodyOwned = _out159; - _559_bodyIdents = _out160; - readIdents = Dafny.Set>.Union(readIdents, _559_bodyIdents); - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("{\nlet r#"), (_552_name)), Dafny.Sequence.UnicodeFromString(": ")), ((_554_valueOwned) ? (Dafny.Sequence.UnicodeFromString("")) : (Dafny.Sequence.UnicodeFromString("&")))), _556_valueTypeGen), Dafny.Sequence.UnicodeFromString(" = ")), _553_valueGen), Dafny.Sequence.UnicodeFromString(";\n")), _557_bodyGen), Dafny.Sequence.UnicodeFromString("\n}")); - isOwned = _558_bodyOwned; + Dafny.ISequence _612_valueGen; + bool _613_valueOwned; + bool _614_valueErased; + Dafny.ISet> _615_recIdents; + Dafny.ISequence _out195; + bool _out196; + bool _out197; + Dafny.ISet> _out198; + DCOMP.COMP.GenExpr(_609_value, @params, false, out _out195, out _out196, out _out197, out _out198); + _612_valueGen = _out195; + _613_valueOwned = _out196; + _614_valueErased = _out197; + _615_recIdents = _out198; + if (_614_valueErased) { + Dafny.ISequence _616_eraseFn; + _616_eraseFn = ((_613_valueOwned) ? (Dafny.Sequence.UnicodeFromString("unerase_owned")) : (Dafny.Sequence.UnicodeFromString("unerase"))); + _612_valueGen = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::"), _616_eraseFn), Dafny.Sequence.UnicodeFromString("(")), _612_valueGen), Dafny.Sequence.UnicodeFromString(")")); + } + readIdents = _615_recIdents; + Dafny.ISequence _617_valueTypeGen; + Dafny.ISequence _out199; + _out199 = DCOMP.COMP.GenType(_610_tpe, false, true); + _617_valueTypeGen = _out199; + Dafny.ISequence _618_bodyGen; + bool _619_bodyOwned; + bool _620_bodyErased; + Dafny.ISet> _621_bodyIdents; + Dafny.ISequence _out200; + bool _out201; + bool _out202; + Dafny.ISet> _out203; + DCOMP.COMP.GenExpr(_608_iifeBody, Dafny.Sequence>.Concat(@params, ((_613_valueOwned) ? (Dafny.Sequence>.FromElements()) : (Dafny.Sequence>.FromElements((_611_name))))), mustOwn, out _out200, out _out201, out _out202, out _out203); + _618_bodyGen = _out200; + _619_bodyOwned = _out201; + _620_bodyErased = _out202; + _621_bodyIdents = _out203; + readIdents = Dafny.Set>.Union(readIdents, _621_bodyIdents); + Dafny.ISequence _622_eraseFn; + _622_eraseFn = ((_613_valueOwned) ? (Dafny.Sequence.UnicodeFromString("unerase_owned")) : (Dafny.Sequence.UnicodeFromString("unerase"))); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("{\nlet r#"), (_611_name)), Dafny.Sequence.UnicodeFromString(": ")), ((_613_valueOwned) ? (Dafny.Sequence.UnicodeFromString("")) : (Dafny.Sequence.UnicodeFromString("&")))), _617_valueTypeGen), Dafny.Sequence.UnicodeFromString(" = ")), _612_valueGen), Dafny.Sequence.UnicodeFromString(";\n")), _618_bodyGen), Dafny.Sequence.UnicodeFromString("\n}")); + isOwned = _619_bodyOwned; + isErased = _620_bodyErased; } } else if (_source16.is_Apply) { - DAST._IExpression _560___mcc_h48 = _source16.dtor_expr; - Dafny.ISequence _561___mcc_h49 = _source16.dtor_args; - Dafny.ISequence _562_args = _561___mcc_h49; - DAST._IExpression _563_func = _560___mcc_h48; + DAST._IExpression _623___mcc_h50 = _source16.dtor_expr; + Dafny.ISequence _624___mcc_h51 = _source16.dtor_args; + Dafny.ISequence _625_args = _624___mcc_h51; + DAST._IExpression _626_func = _623___mcc_h50; { - Dafny.ISequence _564_funcString; - bool _565___v39; - Dafny.ISet> _566_recIdents; - Dafny.ISequence _out161; - bool _out162; - Dafny.ISet> _out163; - DCOMP.COMP.GenExpr(_563_func, @params, false, out _out161, out _out162, out _out163); - _564_funcString = _out161; - _565___v39 = _out162; - _566_recIdents = _out163; - readIdents = _566_recIdents; - Dafny.ISequence _567_argString; - _567_argString = Dafny.Sequence.UnicodeFromString(""); - BigInteger _568_i; - _568_i = BigInteger.Zero; - while ((_568_i) < (new BigInteger((_562_args).Count))) { - if ((_568_i).Sign == 1) { - _567_argString = Dafny.Sequence.Concat(_567_argString, Dafny.Sequence.UnicodeFromString(", ")); + Dafny.ISequence _627_funcString; + bool _628___v46; + bool _629_funcErased; + Dafny.ISet> _630_recIdents; + Dafny.ISequence _out204; + bool _out205; + bool _out206; + Dafny.ISet> _out207; + DCOMP.COMP.GenExpr(_626_func, @params, false, out _out204, out _out205, out _out206, out _out207); + _627_funcString = _out204; + _628___v46 = _out205; + _629_funcErased = _out206; + _630_recIdents = _out207; + readIdents = _630_recIdents; + Dafny.ISequence _631_argString; + _631_argString = Dafny.Sequence.UnicodeFromString(""); + BigInteger _632_i; + _632_i = BigInteger.Zero; + while ((_632_i) < (new BigInteger((_625_args).Count))) { + if ((_632_i).Sign == 1) { + _631_argString = Dafny.Sequence.Concat(_631_argString, Dafny.Sequence.UnicodeFromString(", ")); + } + Dafny.ISequence _633_argExpr; + bool _634_isOwned; + bool _635_argErased; + Dafny.ISet> _636_argIdents; + Dafny.ISequence _out208; + bool _out209; + bool _out210; + Dafny.ISet> _out211; + DCOMP.COMP.GenExpr((_625_args).Select(_632_i), @params, false, out _out208, out _out209, out _out210, out _out211); + _633_argExpr = _out208; + _634_isOwned = _out209; + _635_argErased = _out210; + _636_argIdents = _out211; + if (_634_isOwned) { + _633_argExpr = Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("&"), _633_argExpr); } - Dafny.ISequence _569_argExpr; - bool _570_isOwned; - Dafny.ISet> _571_recIdents; - Dafny.ISequence _out164; - bool _out165; - Dafny.ISet> _out166; - DCOMP.COMP.GenExpr((_562_args).Select(_568_i), @params, false, out _out164, out _out165, out _out166); - _569_argExpr = _out164; - _570_isOwned = _out165; - _571_recIdents = _out166; - readIdents = Dafny.Set>.Union(readIdents, _571_recIdents); - _567_argString = Dafny.Sequence.Concat(Dafny.Sequence.Concat(_567_argString, ((_570_isOwned) ? (Dafny.Sequence.UnicodeFromString("&")) : (Dafny.Sequence.UnicodeFromString("")))), _569_argExpr); - _568_i = (_568_i) + (BigInteger.One); + _631_argString = Dafny.Sequence.Concat(_631_argString, _633_argExpr); + readIdents = Dafny.Set>.Union(readIdents, _636_argIdents); + _632_i = (_632_i) + (BigInteger.One); } - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("(("), _564_funcString), Dafny.Sequence.UnicodeFromString(").0")), Dafny.Sequence.UnicodeFromString("(")), _567_argString), Dafny.Sequence.UnicodeFromString("))")); + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("(("), _627_funcString), Dafny.Sequence.UnicodeFromString(").0")), Dafny.Sequence.UnicodeFromString("(")), _631_argString), Dafny.Sequence.UnicodeFromString("))")); isOwned = true; + isErased = false; } } else if (_source16.is_TypeTest) { - DAST._IExpression _572___mcc_h50 = _source16.dtor_on; - Dafny.ISequence> _573___mcc_h51 = _source16.dtor_dType; - Dafny.ISequence _574___mcc_h52 = _source16.dtor_variant; - Dafny.ISequence _575_variant = _574___mcc_h52; - Dafny.ISequence> _576_dType = _573___mcc_h51; - DAST._IExpression _577_on = _572___mcc_h50; + DAST._IExpression _637___mcc_h52 = _source16.dtor_on; + Dafny.ISequence> _638___mcc_h53 = _source16.dtor_dType; + Dafny.ISequence _639___mcc_h54 = _source16.dtor_variant; + Dafny.ISequence _640_variant = _639___mcc_h54; + Dafny.ISequence> _641_dType = _638___mcc_h53; + DAST._IExpression _642_on = _637___mcc_h52; { - Dafny.ISequence _578_exprGen; - bool _579___v40; - Dafny.ISet> _580_recIdents; - Dafny.ISequence _out167; - bool _out168; - Dafny.ISet> _out169; - DCOMP.COMP.GenExpr(_577_on, @params, false, out _out167, out _out168, out _out169); - _578_exprGen = _out167; - _579___v40 = _out168; - _580_recIdents = _out169; - Dafny.ISequence _581_dTypePath; - Dafny.ISequence _out170; - _out170 = DCOMP.COMP.GenPath(_576_dType); - _581_dTypePath = _out170; - s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("matches!("), _578_exprGen), Dafny.Sequence.UnicodeFromString(".as_ref(), ")), _581_dTypePath), Dafny.Sequence.UnicodeFromString("::r#")), _575_variant), Dafny.Sequence.UnicodeFromString("{ .. })")); + Dafny.ISequence _643_exprGen; + bool _644___v47; + bool _645_exprErased; + Dafny.ISet> _646_recIdents; + Dafny.ISequence _out212; + bool _out213; + bool _out214; + Dafny.ISet> _out215; + DCOMP.COMP.GenExpr(_642_on, @params, false, out _out212, out _out213, out _out214, out _out215); + _643_exprGen = _out212; + _644___v47 = _out213; + _645_exprErased = _out214; + _646_recIdents = _out215; + Dafny.ISequence _647_dTypePath; + Dafny.ISequence _out216; + _out216 = DCOMP.COMP.GenPath(_641_dType); + _647_dTypePath = _out216; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("matches!("), _643_exprGen), Dafny.Sequence.UnicodeFromString(".as_ref(), ")), _647_dTypePath), Dafny.Sequence.UnicodeFromString("::r#")), _640_variant), Dafny.Sequence.UnicodeFromString("{ .. })")); isOwned = true; - readIdents = _580_recIdents; + isErased = true; + readIdents = _646_recIdents; } } else { - DAST._IType _582___mcc_h53 = _source16.dtor_typ; - DAST._IType _583_typ = _582___mcc_h53; + DAST._IType _648___mcc_h55 = _source16.dtor_typ; + DAST._IType _649_typ = _648___mcc_h55; { - s = Dafny.Sequence.UnicodeFromString("std::default::Default::default()"); + Dafny.ISequence _650_typString; + Dafny.ISequence _out217; + _out217 = DCOMP.COMP.GenType(_649_typ, false, false); + _650_typString = _out217; + s = Dafny.Sequence.Concat(Dafny.Sequence.Concat(Dafny.Sequence.UnicodeFromString("<"), _650_typString), Dafny.Sequence.UnicodeFromString(" as std::default::Default>::default()")); isOwned = true; + isErased = false; readIdents = Dafny.Set>.FromElements(); } } @@ -6061,32 +6451,32 @@ public static void GenExpr(DAST._IExpression e, Dafny.ISequence s = Dafny.Sequence.Empty; s = Dafny.Sequence.UnicodeFromString("#![allow(warnings, unconditional_panic)]\n"); s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("extern crate dafny_runtime;\n")); - BigInteger _584_i; - _584_i = BigInteger.Zero; - while ((_584_i) < (new BigInteger((p).Count))) { - Dafny.ISequence _585_generated = Dafny.Sequence.Empty; - Dafny.ISequence _out171; - _out171 = DCOMP.COMP.GenModule((p).Select(_584_i), Dafny.Sequence>.FromElements()); - _585_generated = _out171; - if ((_584_i).Sign == 1) { + BigInteger _651_i; + _651_i = BigInteger.Zero; + while ((_651_i) < (new BigInteger((p).Count))) { + Dafny.ISequence _652_generated = Dafny.Sequence.Empty; + Dafny.ISequence _out218; + _out218 = DCOMP.COMP.GenModule((p).Select(_651_i), Dafny.Sequence>.FromElements()); + _652_generated = _out218; + if ((_651_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("\n")); } - s = Dafny.Sequence.Concat(s, _585_generated); - _584_i = (_584_i) + (BigInteger.One); + s = Dafny.Sequence.Concat(s, _652_generated); + _651_i = (_651_i) + (BigInteger.One); } return s; } public static Dafny.ISequence EmitCallToMain(Dafny.ISequence> fullName) { Dafny.ISequence s = Dafny.Sequence.Empty; s = Dafny.Sequence.UnicodeFromString("\nfn main() {\n"); - BigInteger _586_i; - _586_i = BigInteger.Zero; - while ((_586_i) < (new BigInteger((fullName).Count))) { - if ((_586_i).Sign == 1) { + BigInteger _653_i; + _653_i = BigInteger.Zero; + while ((_653_i) < (new BigInteger((fullName).Count))) { + if ((_653_i).Sign == 1) { s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("::")); } - s = Dafny.Sequence.Concat(s, (fullName).Select(_586_i)); - _586_i = (_586_i) + (BigInteger.One); + s = Dafny.Sequence.Concat(s, (fullName).Select(_653_i)); + _653_i = (_653_i) + (BigInteger.One); } s = Dafny.Sequence.Concat(s, Dafny.Sequence.UnicodeFromString("();\n}")); return s; diff --git a/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.lock b/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.lock index c568c12230c..fbfd5a28610 100644 --- a/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.lock +++ b/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.lock @@ -7,6 +7,7 @@ name = "dafny_runtime" version = "0.1.0" dependencies = [ "once_cell", + "paste", ] [[package]] @@ -14,3 +15,9 @@ name = "once_cell" version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d" + +[[package]] +name = "paste" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" diff --git a/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.toml b/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.toml index 1fecd9a77eb..784934a9430 100644 --- a/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.toml +++ b/Source/DafnyRuntime/DafnyRuntimeRust/Cargo.toml @@ -5,3 +5,4 @@ edition = "2021" [dependencies] once_cell = "1.18.0" +paste = "1.0" diff --git a/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs b/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs index 011d014f013..47235bdca79 100644 --- a/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs +++ b/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs @@ -34,6 +34,28 @@ impl Clone for FunctionWrapper { } } +impl DafnyErasable for FunctionWrapper { + type Erased = FunctionWrapper; + + fn erase(&self) -> &Self::Erased { + self + } + + fn erase_owned(self) -> Self::Erased { + self + } +} + +impl DafnyUnerasable> for FunctionWrapper { + fn unerase(v: &FunctionWrapper) -> &Self { + v + } + + fn unerase_owned(v: FunctionWrapper) -> Self { + v + } +} + pub struct DafnyPrintWrapper(pub T); impl Display for DafnyPrintWrapper<&T> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { @@ -41,6 +63,195 @@ impl Display for DafnyPrintWrapper<&T> { } } +pub trait DafnyErasable: DafnyUnerasable { + type Erased; + + fn erase(&self) -> &Self::Erased; + fn erase_owned(self) -> Self::Erased; +} + +pub trait DafnyUnerasable { + fn unerase(v: &T) -> &Self; + fn unerase_owned(v: T) -> Self; +} + +impl DafnyErasable for Rc { + type Erased = Rc; + + #[inline] + fn erase(&self) -> &Self::Erased { + self + } + + #[inline] + fn erase_owned(self) -> Self::Erased { + self + } +} + +impl DafnyUnerasable> for Rc { + #[inline] + fn unerase(v: &Rc) -> &Self { + v + } + + #[inline] + fn unerase_owned(v: Rc) -> Self { + v + } +} + +impl DafnyErasable for Vec { + type Erased = Vec; + + #[inline] + fn erase(&self) -> &Self::Erased { + self + } + + #[inline] + fn erase_owned(self) -> Self::Erased { + self + } +} + +impl DafnyUnerasable> for Vec { + #[inline] + fn unerase(v: &Vec) -> &Self { + v + } + + #[inline] + fn unerase_owned(v: Vec) -> Self { + v + } +} + +impl DafnyErasable for Box { + type Erased = Box; + + #[inline] + fn erase(&self) -> &Self::Erased { + self + } + + #[inline] + fn erase_owned(self) -> Self::Erased { + self + } +} + +impl DafnyUnerasable> for Box { + #[inline] + fn unerase(v: &Box) -> &Self { + v + } + + #[inline] + fn unerase_owned(v: Box) -> Self { + v + } +} + +macro_rules! impl_already_erased { + ($name:ty) => { + impl DafnyErasable for $name { + type Erased = $name; + + #[inline] + fn erase(&self) -> &Self::Erased { + self + } + + #[inline] + fn erase_owned(self) -> Self::Erased { + self + } + } + + impl DafnyUnerasable<$name> for $name { + #[inline] + fn unerase(v: &$name) -> &Self { + v + } + + #[inline] + fn unerase_owned(v: $name) -> Self { + v + } + } + }; +} + +impl_already_erased! { String } +impl_already_erased! { char } +impl_already_erased! { bool } +impl_already_erased! { u8 } +impl_already_erased! { u16 } +impl_already_erased! { u32 } +impl_already_erased! { u64 } +impl_already_erased! { u128 } +impl_already_erased! { i8 } +impl_already_erased! { i16 } +impl_already_erased! { i32 } +impl_already_erased! { i64 } +impl_already_erased! { i128 } +impl_already_erased! { f32 } +impl_already_erased! { f64 } +impl_already_erased! { () } + +macro_rules! impl_tuple_erased { + ($($items:ident)*) => { + impl <$($items,)*> DafnyErasable for ($($items,)*) + where + $($items: DafnyErasable,)* + { + type Erased = ($($items::Erased,)*); + + #[inline] + fn erase(&self) -> &Self::Erased { + unsafe { &*(self as *const Self as *const Self::Erased) } + } + + #[inline] + fn erase_owned(self) -> Self::Erased { + unsafe { std::mem::transmute_copy(&self) } + } + } + + paste::item! { + impl <$([],)* $($items: DafnyUnerasable<[]>,)*> DafnyUnerasable<($([],)*)> for ($($items,)*) + { + #[inline] + fn unerase(v: &($([],)*)) -> &Self { + unsafe { &*(v as *const ($([],)*) as *const Self) } + } + + #[inline] + fn unerase_owned(v: ($([],)*)) -> Self { + unsafe { std::mem::transmute_copy(&v) } + } + } + } + }; +} + +macro_rules! impl_tuple_erased_loop { + () => {}; + ($first:ident $($rest:ident)*) => { + impl_tuple_erased_loop! { $($rest)* } + impl_tuple_erased! { $first $($rest)* } + }; +} + +// 32 elements ought to be enough for everyone +impl_tuple_erased_loop! { + A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 + A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 + A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 + A31 +} + pub trait DafnyPrint { fn fmt_print(&self, f: &mut Formatter<'_>, in_seq: bool) -> std::fmt::Result; @@ -74,8 +285,18 @@ impl_print_display! { i16 } impl_print_display! { i32 } impl_print_display! { i64 } impl_print_display! { i128 } -impl_print_display! { f32 } -impl_print_display! { f64 } + +impl DafnyPrint for f32 { + fn fmt_print(&self, f: &mut Formatter<'_>, _in_seq: bool) -> std::fmt::Result { + write!(f, "{:.1}", self) + } +} + +impl DafnyPrint for f64 { + fn fmt_print(&self, f: &mut Formatter<'_>, _in_seq: bool) -> std::fmt::Result { + write!(f, "{:.1}", self) + } +} impl DafnyPrint for () { fn fmt_print(&self, f: &mut Formatter<'_>, _in_seq: bool) -> std::fmt::Result { diff --git a/docs/DafnyRef/Features.md b/docs/DafnyRef/Features.md index f76d8fd9b2e..c08b88e2989 100644 --- a/docs/DafnyRef/Features.md +++ b/docs/DafnyRef/Features.md @@ -1,25 +1,25 @@ | Feature | C# | JavaScript | Go | Java | Python | C++ | Dafny Library (.doo) | Rust | |-|-|-|-|-|-|-|-|-| -| [Unbounded integers](#sec-numeric-types) | X | X | X | X | X | | X | | -| [Real numbers](#sec-numeric-types) | X | X | X | X | X | | X | | +| [Unbounded integers](#sec-numeric-types) | X | X | X | X | X | | X | X | +| [Real numbers](#sec-numeric-types) | X | X | X | X | X | | X | X | | [Ordinals](#sec-ordinals) | X | X | X | X | X | | X | | -| [Function values](#sec-arrow-subset-types) | X | X | X | X | X | | X | | +| [Function values](#sec-arrow-subset-types) | X | X | X | X | X | | X | X | | [Iterators](#sec-iterator-types) | X | X | X | | X | | X | | -| [Collections with trait element types](#sec-collection-types) | X | X | X | X | X | | X | | -| [External module names with only underscores](#sec-extern-decls) | X | X | | X | X | X | X | | +| [Collections with trait element types](#sec-collection-types) | X | X | X | X | X | | X | X | +| [External module names with only underscores](#sec-extern-decls) | X | X | | X | X | X | X | X | | [Co-inductive datatypes](#sec-coinductive-datatypes) | X | X | X | X | X | | X | X | | [Multisets](#sec-multisets) | X | X | X | X | X | | X | | -| [Runtime type descriptors](#) | X | X | X | X | X | | X | | -| [Multi-dimensional arrays](#sec-multi-dimensional-arrays) | X | X | X | X | X | | X | | +| [Runtime type descriptors](#) | X | X | X | X | X | | X | X | +| [Multi-dimensional arrays](#sec-multi-dimensional-arrays) | X | X | X | X | X | | X | X | | [Map comprehensions](#sec-map-comprehension-expression) | X | X | X | X | X | | X | | | [Traits](#sec-trait-types) | X | X | X | X | X | | X | X | | [Let-such-that expressions](#sec-let-expression) | X | X | X | X | X | | X | | -| [Non-native numeric newtypes](#sec-newtypes) | X | X | X | X | X | | X | | +| [Non-native numeric newtypes](#sec-newtypes) | X | X | X | X | X | | X | X | | [Method synthesis](#sec-synthesize-attr) | X | | | | | | X | | | [External classes](#sec-extern-decls) | X | X | X | X | X | | X | | | [Instantiating the `object` type](#sec-object-type) | X | X | X | X | X | | X | | | [`forall` statements that cannot be sequentialized](#sec-forall-statement)[^compiler-feature-forall-note] | X | X | X | X | X | | X | | -| [Taking an array's length](#sec-array-type) | X | X | X | X | X | | X | | +| [Taking an array's length](#sec-array-type) | X | X | X | X | X | | X | X | | [`m.Items` when `m` is a map](#sec-maps) | X | X | X | X | X | | X | | | [The /runAllTests option](#sec-test-attribute) | X | X | X | X | X | | X | | | [Integer range constraints in quantifiers (e.g. `a <= x <= b`)](#sec-quantifier-domains) | X | X | X | X | X | X | X | | @@ -35,7 +35,7 @@ | [Sequence update expressions](#sec-other-sequence-expressions) | X | X | X | X | X | X | X | | | [Sequence constructions with non-lambda initializers](#sec-sequence-displays)[^compiler-sequence-display-nolambda-note] | X | X | X | X | X | X | X | | | [Externally-implemented constructors](#sec-extern-decls) | X | | | X | X | X | X | | -| [Auto-initialization of tuple variables](#sec-tuple-types) | X | X | X | X | X | X | X | | +| [Auto-initialization of tuple variables](#sec-tuple-types) | X | X | X | X | X | X | X | X | | [Subtype constraints in quantifiers](#sec-quantifier-expression) | X | X | X | X | X | X | X | | | [Tuples with more than 20 arguments](#sec-tuple-types) | | X | X | | X | X | X | | | [Unicode chars](##sec-characters) | X | X | X | X | X | | X | X |