mirror of
https://github.com/roc-lang/roc.git
synced 2024-10-04 06:08:10 +03:00
Merge remote-tracking branch 'remote/main' into result-map-builtins
This commit is contained in:
commit
2eb3e38b7f
6
.github/workflows/ci_manager.yml
vendored
6
.github/workflows/ci_manager.yml
vendored
@ -104,10 +104,10 @@ jobs:
|
||||
if: needs.check-changes.outputs.run_tests == 'full'
|
||||
uses: ./.github/workflows/ubuntu_x86_64.yml
|
||||
|
||||
start-ubuntu-x86-64-tests-debug:
|
||||
start-ubuntu-x86-64-nix-tests-debug:
|
||||
needs: check-changes
|
||||
if: needs.check-changes.outputs.run_tests == 'full'
|
||||
uses: ./.github/workflows/ubuntu_x86_64_debug.yml
|
||||
uses: ./.github/workflows/ubuntu_x86_64_nix_debug.yml
|
||||
|
||||
start-windows-release-build-test:
|
||||
needs: check-changes
|
||||
@ -133,7 +133,7 @@ jobs:
|
||||
start-nix-macos-apple-silicon-tests,
|
||||
start-macos-x86-64-tests,
|
||||
start-ubuntu-x86-64-tests,
|
||||
start-ubuntu-x86-64-tests-debug,
|
||||
start-ubuntu-x86-64-nix-tests-debug,
|
||||
start-windows-release-build-test,
|
||||
start-windows-tests,
|
||||
start-roc-benchmarks
|
||||
|
42
.github/workflows/ubuntu_x86_64_debug.yml
vendored
42
.github/workflows/ubuntu_x86_64_debug.yml
vendored
@ -1,42 +0,0 @@
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
name: cargo test debug
|
||||
|
||||
env:
|
||||
RUST_BACKTRACE: 1
|
||||
|
||||
jobs:
|
||||
cargo-test-debug:
|
||||
name: cargo test debug
|
||||
runs-on: [ubuntu-22.04]
|
||||
timeout-minutes: 90
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: goto-bus-stop/setup-zig@v2
|
||||
with:
|
||||
version: 0.11.0
|
||||
|
||||
- run: zig version
|
||||
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
sudo apt -y install build-essential libunwind-dev pkg-config zlib1g-dev valgrind
|
||||
wget https://apt.llvm.org/llvm.sh
|
||||
chmod +x llvm.sh
|
||||
sudo ./llvm.sh 16
|
||||
sudo rm /usr/bin/clang
|
||||
sudo ln -s /usr/bin/clang-16 /usr/bin/clang
|
||||
sudo ln -s /usr/bin/lld-16 /usr/bin/ld.lld
|
||||
sudo apt -y install libpolly-16-dev
|
||||
|
||||
- name: Check if debug flag files are in sync
|
||||
run: ./ci/check_debug_vars.sh
|
||||
|
||||
# for skipped tests; see #6946, #6947
|
||||
- name: cargo test without --release
|
||||
env:
|
||||
RUSTFLAGS: -C link-arg=-fuse-ld=lld
|
||||
ROC_CHECK_MONO_IR: 1
|
||||
run: cargo test -- --skip tests/exhaustive/match_on_result_with_uninhabited_error_destructuring_in_lambda_syntax.txt --skip tests::identity_lambda --skip tests::issue_2300 --skip tests::issue_2582_specialize_result_value --skip tests::sum_lambda
|
27
.github/workflows/ubuntu_x86_64_nix_debug.yml
vendored
Normal file
27
.github/workflows/ubuntu_x86_64_nix_debug.yml
vendored
Normal file
@ -0,0 +1,27 @@
|
||||
on:
|
||||
workflow_call:
|
||||
|
||||
name: cargo test debug nix
|
||||
|
||||
env:
|
||||
RUST_BACKTRACE: 1
|
||||
|
||||
jobs:
|
||||
cargo-test-debug-nix:
|
||||
name: cargo test debug nix
|
||||
runs-on: [ubuntu-22.04]
|
||||
timeout-minutes: 90
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
# install nix
|
||||
- uses: cachix/install-nix-action@v23
|
||||
with:
|
||||
nix_path: nixpkgs=channel:nixos-unstable
|
||||
|
||||
- name: Check if debug flag files are in sync
|
||||
run: ./ci/check_debug_vars.sh
|
||||
|
||||
# for skipped tests; see #6946, #6947
|
||||
- name: cargo test without --release
|
||||
run: nix develop -c sh -c 'export ROC_CHECK_MONO_IR=1 && cargo test -- --skip tests/exhaustive/match_on_result_with_uninhabited_error_destructuring_in_lambda_syntax.txt --skip tests::identity_lambda --skip tests::issue_2300 --skip tests::issue_2582_specialize_result_value --skip tests::sum_lambda'
|
@ -1,6 +1,6 @@
|
||||
use crate::env::Env;
|
||||
use crate::procedure::{QualifiedReference, References};
|
||||
use crate::scope::{PendingAbilitiesInScope, Scope};
|
||||
use crate::scope::{PendingAbilitiesInScope, Scope, SymbolLookup};
|
||||
use roc_collections::{ImMap, MutSet, SendMap, VecMap, VecSet};
|
||||
use roc_module::ident::{Ident, Lowercase, TagName};
|
||||
use roc_module::symbol::Symbol;
|
||||
@ -386,7 +386,10 @@ pub(crate) fn make_apply_symbol(
|
||||
// Look it up in scope!
|
||||
|
||||
match scope.lookup_str(ident, region) {
|
||||
Ok(symbol) => {
|
||||
Ok(SymbolLookup {
|
||||
symbol,
|
||||
module_params: _,
|
||||
}) => {
|
||||
references.insert_type_lookup(symbol, QualifiedReference::Unqualified);
|
||||
Ok(symbol)
|
||||
}
|
||||
@ -398,7 +401,10 @@ pub(crate) fn make_apply_symbol(
|
||||
}
|
||||
} else {
|
||||
match env.qualified_lookup(scope, module_name, ident, region) {
|
||||
Ok(symbol) => {
|
||||
Ok(SymbolLookup {
|
||||
symbol,
|
||||
module_params: _,
|
||||
}) => {
|
||||
references.insert_type_lookup(symbol, QualifiedReference::Qualified);
|
||||
Ok(symbol)
|
||||
}
|
||||
|
@ -602,7 +602,8 @@ impl Constraints {
|
||||
| Constraint::Exhaustive { .. }
|
||||
| Constraint::Resolve(..)
|
||||
| Constraint::IngestedFile(..)
|
||||
| Constraint::CheckCycle(..) => false,
|
||||
| Constraint::CheckCycle(..)
|
||||
| Constraint::ImportParams(..) => false,
|
||||
}
|
||||
}
|
||||
|
||||
@ -685,6 +686,15 @@ impl Constraints {
|
||||
) -> Constraint {
|
||||
Constraint::IngestedFile(type_index, file_path, bytes)
|
||||
}
|
||||
|
||||
pub fn import_params(
|
||||
&mut self,
|
||||
opt_type_index: Option<TypeOrVar>,
|
||||
module_id: ModuleId,
|
||||
region: Region,
|
||||
) -> Constraint {
|
||||
Constraint::ImportParams(opt_type_index, module_id, region)
|
||||
}
|
||||
}
|
||||
|
||||
roc_error_macros::assert_sizeof_default!(Constraint, 3 * 8);
|
||||
@ -787,6 +797,7 @@ pub enum Constraint {
|
||||
CheckCycle(Index<Cycle>, IllegalCycleMark),
|
||||
|
||||
IngestedFile(TypeOrVar, Box<PathBuf>, Arc<Vec<u8>>),
|
||||
ImportParams(Option<TypeOrVar>, ModuleId, Region),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
@ -865,6 +876,9 @@ impl std::fmt::Debug for Constraint {
|
||||
Self::IngestedFile(arg0, arg1, arg2) => {
|
||||
write!(f, "IngestedFile({arg0:?}, {arg1:?}, {arg2:?})")
|
||||
}
|
||||
Self::ImportParams(arg0, arg1, arg2) => {
|
||||
write!(f, "ImportParams({arg0:?}, {arg1:?}, {arg2:?})")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -288,6 +288,22 @@ fn deep_copy_expr_help<C: CopyEnv>(env: &mut C, copied: &mut Vec<Variable>, expr
|
||||
loc_elems: loc_elems.iter().map(|le| le.map(|e| go_help!(e))).collect(),
|
||||
},
|
||||
Var(sym, var) => Var(*sym, sub!(*var)),
|
||||
ParamsVar {
|
||||
symbol,
|
||||
params,
|
||||
var,
|
||||
} => ParamsVar {
|
||||
symbol: *symbol,
|
||||
params: *params,
|
||||
var: sub!(*var),
|
||||
},
|
||||
ImportParams(module_id, region, opt_provided) => ImportParams(
|
||||
*module_id,
|
||||
*region,
|
||||
opt_provided
|
||||
.as_ref()
|
||||
.map(|(var, expr)| (sub!(*var), Box::new(go_help!(&expr)))),
|
||||
),
|
||||
&AbilityMember(sym, specialization, specialization_var) => {
|
||||
AbilityMember(sym, specialization, sub!(specialization_var))
|
||||
}
|
||||
|
@ -206,7 +206,13 @@ fn expr<'a>(c: &Ctx, p: EPrec, f: &'a Arena<'a>, e: &'a Expr) -> DocBuilder<'a,
|
||||
.append("]")
|
||||
.group(),
|
||||
),
|
||||
Var(sym, _) | AbilityMember(sym, _, _) => pp_sym(c, f, *sym),
|
||||
Var(sym, _) | ParamsVar { symbol: sym, .. } | AbilityMember(sym, _, _) => {
|
||||
pp_sym(c, f, *sym)
|
||||
}
|
||||
ImportParams(_, _, Some((_, params_expr))) => expr(c, p, f, params_expr),
|
||||
ImportParams(module_id, _, None) => {
|
||||
text!(f, "<no params for {:?}>", module_id)
|
||||
}
|
||||
When {
|
||||
loc_cond, branches, ..
|
||||
} => maybe_paren!(
|
||||
|
@ -10,6 +10,7 @@ use crate::annotation::IntroducedVariables;
|
||||
use crate::annotation::OwnedNamedOrAble;
|
||||
use crate::derive;
|
||||
use crate::env::Env;
|
||||
use crate::expr::canonicalize_record;
|
||||
use crate::expr::get_lookup_symbols;
|
||||
use crate::expr::AnnotatedMark;
|
||||
use crate::expr::ClosureData;
|
||||
@ -18,6 +19,7 @@ use crate::expr::Expr::{self, *};
|
||||
use crate::expr::StructAccessorData;
|
||||
use crate::expr::{canonicalize_expr, Output, Recursive};
|
||||
use crate::pattern::{canonicalize_def_header_pattern, BindingsFromPattern, Pattern};
|
||||
use crate::procedure::QualifiedReference;
|
||||
use crate::procedure::References;
|
||||
use crate::scope::create_alias;
|
||||
use crate::scope::{PendingAbilitiesInScope, Scope};
|
||||
@ -160,6 +162,13 @@ enum PendingValueDef<'a> {
|
||||
&'a Loc<ast::TypeAnnotation<'a>>,
|
||||
&'a Loc<ast::Expr<'a>>,
|
||||
),
|
||||
/// Module params from an import
|
||||
ImportParams {
|
||||
symbol: Symbol,
|
||||
loc_pattern: Loc<Pattern>,
|
||||
module_id: ModuleId,
|
||||
opt_provided: Option<ast::Collection<'a, Loc<AssignedField<'a, ast::Expr<'a>>>>>,
|
||||
},
|
||||
/// Ingested file
|
||||
IngestedFile(
|
||||
Loc<Pattern>,
|
||||
@ -174,6 +183,12 @@ impl PendingValueDef<'_> {
|
||||
PendingValueDef::AnnotationOnly(loc_pattern, _) => loc_pattern,
|
||||
PendingValueDef::Body(loc_pattern, _) => loc_pattern,
|
||||
PendingValueDef::TypedBody(_, loc_pattern, _, _) => loc_pattern,
|
||||
PendingValueDef::ImportParams {
|
||||
loc_pattern,
|
||||
symbol: _,
|
||||
module_id: _,
|
||||
opt_provided: _,
|
||||
} => loc_pattern,
|
||||
PendingValueDef::IngestedFile(loc_pattern, _, _) => loc_pattern,
|
||||
}
|
||||
}
|
||||
@ -485,6 +500,16 @@ fn canonicalize_alias<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! params_in_abilities_unimplemented {
|
||||
($lookup:expr) => {
|
||||
match $lookup.module_params {
|
||||
None => $lookup.symbol,
|
||||
Some(_) => unimplemented!("params in abilities"),
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Canonicalizes a claimed ability implementation like `{ eq }` or `{ eq: myEq }`.
|
||||
/// Returns a mapping of the ability member to the implementation symbol.
|
||||
/// If there was an error, a problem will be recorded and nothing is returned.
|
||||
@ -503,7 +528,7 @@ fn canonicalize_claimed_ability_impl<'a>(
|
||||
|
||||
let member_symbol =
|
||||
match env.qualified_lookup_with_module_id(scope, ability_home, label_str, region) {
|
||||
Ok(symbol) => symbol,
|
||||
Ok(lookup) => params_in_abilities_unimplemented!(lookup),
|
||||
Err(_) => {
|
||||
env.problem(Problem::NotAnAbilityMember {
|
||||
ability,
|
||||
@ -546,8 +571,13 @@ fn canonicalize_claimed_ability_impl<'a>(
|
||||
// To handle both cases, try checking for a shadow first, then check for a direct
|
||||
// reference. We want to check for a direct reference second so that if there is a
|
||||
// shadow, we won't accidentally grab the imported symbol.
|
||||
let opt_impl_symbol = (scope.lookup_ability_member_shadow(member_symbol))
|
||||
.or_else(|| scope.lookup_str(label_str, region).ok());
|
||||
let opt_impl_symbol =
|
||||
(scope.lookup_ability_member_shadow(member_symbol)).or_else(|| {
|
||||
scope
|
||||
.lookup_str(label_str, region)
|
||||
.map(|s| params_in_abilities_unimplemented!(s))
|
||||
.ok()
|
||||
});
|
||||
|
||||
match opt_impl_symbol {
|
||||
// It's possible that even if we find a symbol it is still only the member
|
||||
@ -599,7 +629,7 @@ fn canonicalize_claimed_ability_impl<'a>(
|
||||
label.value,
|
||||
label.region,
|
||||
) {
|
||||
Ok(symbol) => symbol,
|
||||
Ok(lookup) => params_in_abilities_unimplemented!(lookup),
|
||||
Err(_) => {
|
||||
env.problem(Problem::NotAnAbilityMember {
|
||||
ability,
|
||||
@ -611,7 +641,7 @@ fn canonicalize_claimed_ability_impl<'a>(
|
||||
};
|
||||
|
||||
let impl_symbol = match scope.lookup(&impl_ident.into(), impl_region) {
|
||||
Ok(symbol) => symbol,
|
||||
Ok(symbol) => params_in_abilities_unimplemented!(symbol),
|
||||
Err(err) => {
|
||||
env.problem(Problem::RuntimeError(err));
|
||||
return Err(());
|
||||
@ -1109,8 +1139,24 @@ fn canonicalize_value_defs<'a>(
|
||||
PendingValue::ExpectFx(pending_expect) => {
|
||||
pending_expect_fx.push(pending_expect);
|
||||
}
|
||||
PendingValue::ModuleImport(introduced_import) => {
|
||||
imports_introduced.push(introduced_import);
|
||||
PendingValue::ModuleImport(PendingModuleImport {
|
||||
module_id,
|
||||
region,
|
||||
exposed_symbols,
|
||||
params,
|
||||
}) => {
|
||||
imports_introduced.push(IntroducedImport {
|
||||
module_id,
|
||||
region,
|
||||
exposed_symbols,
|
||||
});
|
||||
|
||||
pending_value_defs.push(PendingValueDef::ImportParams {
|
||||
symbol: params.symbol,
|
||||
loc_pattern: params.loc_pattern,
|
||||
opt_provided: params.opt_provided,
|
||||
module_id,
|
||||
});
|
||||
}
|
||||
PendingValue::InvalidIngestedFile => { /* skip */ }
|
||||
PendingValue::ImportNameConflict => { /* skip */ }
|
||||
@ -1558,7 +1604,7 @@ impl DefOrdering {
|
||||
fn insert_symbol_references(&mut self, def_id: u32, def_references: &DefReferences) {
|
||||
match def_references {
|
||||
DefReferences::Value(references) => {
|
||||
let it = references.value_lookups().chain(references.calls());
|
||||
let it = references.value_lookups();
|
||||
|
||||
for referenced in it {
|
||||
if let Some(ref_id) = self.get_id(*referenced) {
|
||||
@ -2352,6 +2398,50 @@ fn canonicalize_pending_value_def<'a>(
|
||||
None,
|
||||
)
|
||||
}
|
||||
ImportParams {
|
||||
symbol,
|
||||
loc_pattern,
|
||||
module_id,
|
||||
opt_provided,
|
||||
} => {
|
||||
// Insert a reference to the record so that we don't report it as unused
|
||||
// If the whole module is unused, we'll report that separately
|
||||
output
|
||||
.references
|
||||
.insert_value_lookup(symbol, QualifiedReference::Unqualified);
|
||||
|
||||
let (opt_var_record, references) = match opt_provided {
|
||||
Some(params) => {
|
||||
let (record, can_output) =
|
||||
canonicalize_record(env, var_store, scope, loc_pattern.region, params);
|
||||
|
||||
let references = can_output.references.clone();
|
||||
output.union(can_output);
|
||||
|
||||
(Some((var_store.fresh(), Box::new(record))), references)
|
||||
}
|
||||
None => (None, References::new()),
|
||||
};
|
||||
|
||||
let loc_expr = Loc::at(
|
||||
loc_pattern.region,
|
||||
Expr::ImportParams(module_id, loc_pattern.region, opt_var_record),
|
||||
);
|
||||
|
||||
let def = single_can_def(
|
||||
loc_pattern,
|
||||
loc_expr,
|
||||
var_store.fresh(),
|
||||
None,
|
||||
SendMap::default(),
|
||||
);
|
||||
|
||||
DefOutput {
|
||||
output,
|
||||
references: DefReferences::Value(references),
|
||||
def,
|
||||
}
|
||||
}
|
||||
IngestedFile(loc_pattern, opt_loc_ann, path_literal) => {
|
||||
let relative_path =
|
||||
if let ast::StrLiteral::PlainLine(ingested_path) = path_literal.value {
|
||||
@ -2893,7 +2983,7 @@ enum PendingValue<'a> {
|
||||
Dbg(PendingExpectOrDbg<'a>),
|
||||
Expect(PendingExpectOrDbg<'a>),
|
||||
ExpectFx(PendingExpectOrDbg<'a>),
|
||||
ModuleImport(IntroducedImport),
|
||||
ModuleImport(PendingModuleImport<'a>),
|
||||
SignatureDefMismatch,
|
||||
InvalidIngestedFile,
|
||||
ImportNameConflict,
|
||||
@ -2904,6 +2994,19 @@ struct PendingExpectOrDbg<'a> {
|
||||
preceding_comment: Region,
|
||||
}
|
||||
|
||||
struct PendingModuleImport<'a> {
|
||||
module_id: ModuleId,
|
||||
region: Region,
|
||||
exposed_symbols: Vec<(Symbol, Region)>,
|
||||
params: PendingModuleImportParams<'a>,
|
||||
}
|
||||
|
||||
struct PendingModuleImportParams<'a> {
|
||||
symbol: Symbol,
|
||||
loc_pattern: Loc<Pattern>,
|
||||
opt_provided: Option<ast::Collection<'a, Loc<AssignedField<'a, ast::Expr<'a>>>>>,
|
||||
}
|
||||
|
||||
pub struct IntroducedImport {
|
||||
module_id: ModuleId,
|
||||
region: Region,
|
||||
@ -3053,10 +3156,27 @@ fn to_pending_value_def<'a>(
|
||||
None => module_name.clone(),
|
||||
};
|
||||
|
||||
// Generate a symbol for the module params def
|
||||
// We do this even if params weren't provided so that solve can report if they are missing
|
||||
let params_sym = scope.gen_unique_symbol();
|
||||
let params_region = module_import.params.map(|p| p.params.region).unwrap_or(region);
|
||||
let params =
|
||||
PendingModuleImportParams {
|
||||
symbol: params_sym,
|
||||
loc_pattern: Loc::at(params_region, Pattern::Identifier(params_sym)),
|
||||
opt_provided: module_import.params.map(|p| p.params.value),
|
||||
};
|
||||
let provided_params_sym = if module_import.params.is_some() {
|
||||
// Only add params to scope if they are provided
|
||||
Some(params_sym)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
if let Err(existing_import) =
|
||||
scope
|
||||
.modules
|
||||
.insert(name_with_alias.clone(), module_id, region)
|
||||
.insert(name_with_alias.clone(), module_id, provided_params_sym, region)
|
||||
{
|
||||
env.problems.push(Problem::ImportNameConflict {
|
||||
name: name_with_alias,
|
||||
@ -3067,7 +3187,7 @@ fn to_pending_value_def<'a>(
|
||||
});
|
||||
|
||||
return PendingValue::ImportNameConflict;
|
||||
}
|
||||
};
|
||||
|
||||
let exposed_names = module_import
|
||||
.exposed
|
||||
@ -3119,13 +3239,13 @@ fn to_pending_value_def<'a>(
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
PendingValue::ModuleImport(IntroducedImport {
|
||||
PendingValue::ModuleImport(PendingModuleImport {
|
||||
module_id,
|
||||
region,
|
||||
exposed_symbols,
|
||||
params,
|
||||
})
|
||||
}
|
||||
IngestedFileImport(ingested_file) => {
|
||||
|
@ -140,7 +140,9 @@ fn desugar_value_def<'a>(
|
||||
let desugared_params =
|
||||
params.map(|ModuleImportParams { before, params }| ModuleImportParams {
|
||||
before,
|
||||
params: desugar_field_collection(arena, params, src, line_info, module_path),
|
||||
params: params.map(|params| {
|
||||
desugar_field_collection(arena, *params, src, line_info, module_path)
|
||||
}),
|
||||
});
|
||||
|
||||
ModuleImport(roc_parse::ast::ModuleImport {
|
||||
|
@ -1,7 +1,7 @@
|
||||
use std::path::Path;
|
||||
|
||||
use crate::procedure::References;
|
||||
use crate::scope::Scope;
|
||||
use crate::scope::{ModuleLookup, Scope, SymbolLookup};
|
||||
use bumpalo::Bump;
|
||||
use roc_collections::{MutMap, VecSet};
|
||||
use roc_module::ident::{Ident, ModuleName};
|
||||
@ -74,7 +74,7 @@ impl<'a> Env<'a> {
|
||||
module_name_str: &str,
|
||||
ident: &str,
|
||||
region: Region,
|
||||
) -> Result<Symbol, RuntimeError> {
|
||||
) -> Result<SymbolLookup, RuntimeError> {
|
||||
debug_assert!(
|
||||
!module_name_str.is_empty(),
|
||||
"Called env.qualified_lookup with an unqualified ident: {ident:?}"
|
||||
@ -82,8 +82,10 @@ impl<'a> Env<'a> {
|
||||
|
||||
let module_name = ModuleName::from(module_name_str);
|
||||
|
||||
match scope.modules.get_id(&module_name) {
|
||||
Some(module_id) => self.qualified_lookup_help(scope, module_id, ident, region),
|
||||
match scope.modules.lookup(&module_name) {
|
||||
Some(lookedup_module) => {
|
||||
self.qualified_lookup_help(scope, lookedup_module, ident, region)
|
||||
}
|
||||
None => Err(RuntimeError::ModuleNotImported {
|
||||
module_name: module_name.clone(),
|
||||
imported_modules: scope
|
||||
@ -106,11 +108,11 @@ impl<'a> Env<'a> {
|
||||
module_id: ModuleId,
|
||||
ident: &str,
|
||||
region: Region,
|
||||
) -> Result<Symbol, RuntimeError> {
|
||||
if !scope.modules.has_id(module_id) {
|
||||
Err(self.module_exists_but_not_imported(scope, module_id, region))
|
||||
) -> Result<SymbolLookup, RuntimeError> {
|
||||
if let Some(module) = scope.modules.lookup_by_id(&module_id) {
|
||||
self.qualified_lookup_help(scope, module, ident, region)
|
||||
} else {
|
||||
self.qualified_lookup_help(scope, module_id, ident, region)
|
||||
Err(self.module_exists_but_not_imported(scope, module_id, region))
|
||||
}
|
||||
}
|
||||
|
||||
@ -118,18 +120,18 @@ impl<'a> Env<'a> {
|
||||
fn qualified_lookup_help(
|
||||
&mut self,
|
||||
scope: &Scope,
|
||||
module_id: ModuleId,
|
||||
module: ModuleLookup,
|
||||
ident: &str,
|
||||
region: Region,
|
||||
) -> Result<Symbol, RuntimeError> {
|
||||
) -> Result<SymbolLookup, RuntimeError> {
|
||||
let is_type_name = ident.starts_with(|c: char| c.is_uppercase());
|
||||
|
||||
// You can do qualified lookups on your own module, e.g.
|
||||
// if I'm in the Foo module, I can do a `Foo.bar` lookup.
|
||||
if module_id == self.home {
|
||||
if module.id == self.home {
|
||||
match scope.locals.ident_ids.get_id(ident) {
|
||||
Some(ident_id) => {
|
||||
let symbol = Symbol::new(module_id, ident_id);
|
||||
let symbol = Symbol::new(module.id, ident_id);
|
||||
|
||||
if is_type_name {
|
||||
self.qualified_type_lookups.insert(symbol);
|
||||
@ -137,7 +139,7 @@ impl<'a> Env<'a> {
|
||||
self.qualified_value_lookups.insert(symbol);
|
||||
}
|
||||
|
||||
Ok(symbol)
|
||||
Ok(SymbolLookup::no_params(symbol))
|
||||
}
|
||||
None => {
|
||||
let error = RuntimeError::LookupNotInScope {
|
||||
@ -157,10 +159,10 @@ impl<'a> Env<'a> {
|
||||
}
|
||||
}
|
||||
} else {
|
||||
match self.dep_idents.get(&module_id) {
|
||||
match self.dep_idents.get(&module.id) {
|
||||
Some(exposed_ids) => match exposed_ids.get_id(ident) {
|
||||
Some(ident_id) => {
|
||||
let symbol = Symbol::new(module_id, ident_id);
|
||||
let symbol = Symbol::new(module.id, ident_id);
|
||||
|
||||
if is_type_name {
|
||||
self.qualified_type_lookups.insert(symbol);
|
||||
@ -168,12 +170,12 @@ impl<'a> Env<'a> {
|
||||
self.qualified_value_lookups.insert(symbol);
|
||||
}
|
||||
|
||||
Ok(symbol)
|
||||
Ok(module.into_symbol(symbol))
|
||||
}
|
||||
None => Err(RuntimeError::ValueNotExposed {
|
||||
module_name: self
|
||||
.qualified_module_ids
|
||||
.get_name(module_id)
|
||||
.get_name(module.id)
|
||||
.expect("Module ID known, but not in the module IDs somehow")
|
||||
.as_inner()
|
||||
.clone(),
|
||||
@ -182,7 +184,7 @@ impl<'a> Env<'a> {
|
||||
exposed_values: exposed_ids.exposed_values(),
|
||||
}),
|
||||
},
|
||||
_ => Err(self.module_exists_but_not_imported(scope, module_id, region)),
|
||||
_ => Err(self.module_exists_but_not_imported(scope, module.id, region)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -7,9 +7,10 @@ use crate::num::{
|
||||
finish_parsing_base, finish_parsing_float, finish_parsing_num, float_expr_from_result,
|
||||
int_expr_from_result, num_expr_from_result, FloatBound, IntBound, NumBound,
|
||||
};
|
||||
use crate::params_in_abilities_unimplemented;
|
||||
use crate::pattern::{canonicalize_pattern, BindingsFromPattern, Pattern, PermitShadows};
|
||||
use crate::procedure::{QualifiedReference, References};
|
||||
use crate::scope::Scope;
|
||||
use crate::scope::{Scope, SymbolLookup};
|
||||
use crate::traverse::{walk_expr, Visitor};
|
||||
use roc_collections::soa::Index;
|
||||
use roc_collections::{SendMap, VecMap, VecSet};
|
||||
@ -17,7 +18,7 @@ use roc_error_macros::internal_error;
|
||||
use roc_module::called_via::CalledVia;
|
||||
use roc_module::ident::{ForeignSymbol, Lowercase, TagName};
|
||||
use roc_module::low_level::LowLevel;
|
||||
use roc_module::symbol::Symbol;
|
||||
use roc_module::symbol::{ModuleId, Symbol};
|
||||
use roc_parse::ast::{self, Defs, PrecedenceConflict, StrLiteral};
|
||||
use roc_parse::ident::Accessor;
|
||||
use roc_parse::pattern::PatternType::*;
|
||||
@ -107,6 +108,12 @@ pub enum Expr {
|
||||
|
||||
// Lookups
|
||||
Var(Symbol, Variable),
|
||||
/// Like Var, but from a module with params
|
||||
ParamsVar {
|
||||
symbol: Symbol,
|
||||
params: Symbol,
|
||||
var: Variable,
|
||||
},
|
||||
AbilityMember(
|
||||
/// Actual member name
|
||||
Symbol,
|
||||
@ -177,6 +184,9 @@ pub enum Expr {
|
||||
elems: Vec<(Variable, Box<Loc<Expr>>)>,
|
||||
},
|
||||
|
||||
/// Module params expression in import
|
||||
ImportParams(ModuleId, Region, Option<(Variable, Box<Expr>)>),
|
||||
|
||||
/// The "crash" keyword
|
||||
Crash {
|
||||
msg: Box<Loc<Expr>>,
|
||||
@ -308,6 +318,11 @@ impl Expr {
|
||||
Self::SingleQuote(..) => Category::Character,
|
||||
Self::List { .. } => Category::List,
|
||||
&Self::Var(sym, _) => Category::Lookup(sym),
|
||||
&Self::ParamsVar {
|
||||
symbol,
|
||||
params: _,
|
||||
var: _,
|
||||
} => Category::Lookup(symbol),
|
||||
&Self::AbilityMember(sym, _, _) => Category::Lookup(sym),
|
||||
Self::When { .. } => Category::When,
|
||||
Self::If { .. } => Category::If,
|
||||
@ -324,6 +339,8 @@ impl Expr {
|
||||
Self::RecordAccessor(data) => Category::Accessor(data.field.clone()),
|
||||
Self::TupleAccess { index, .. } => Category::TupleAccess(*index),
|
||||
Self::RecordUpdate { .. } => Category::Record,
|
||||
Self::ImportParams(_, _, Some((_, expr))) => expr.category(),
|
||||
Self::ImportParams(_, _, None) => Category::Unknown,
|
||||
Self::Tag {
|
||||
name, arguments, ..
|
||||
} => Category::TagApply {
|
||||
@ -632,33 +649,8 @@ pub fn canonicalize_expr<'a>(
|
||||
(answer, Output::default())
|
||||
}
|
||||
ast::Expr::Record(fields) => {
|
||||
if fields.is_empty() {
|
||||
(EmptyRecord, Output::default())
|
||||
} else {
|
||||
match canonicalize_fields(env, var_store, scope, region, fields.items) {
|
||||
Ok((can_fields, output)) => (
|
||||
Record {
|
||||
record_var: var_store.fresh(),
|
||||
fields: can_fields,
|
||||
},
|
||||
output,
|
||||
),
|
||||
Err(CanonicalizeRecordProblem::InvalidOptionalValue {
|
||||
field_name,
|
||||
field_region,
|
||||
record_region,
|
||||
}) => (
|
||||
Expr::RuntimeError(roc_problem::can::RuntimeError::InvalidOptionalValue {
|
||||
field_name,
|
||||
field_region,
|
||||
record_region,
|
||||
}),
|
||||
Output::default(),
|
||||
),
|
||||
canonicalize_record(env, var_store, scope, region, *fields)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ast::Expr::RecordUpdate {
|
||||
fields,
|
||||
update: loc_update,
|
||||
@ -1452,6 +1444,42 @@ pub fn canonicalize_expr<'a>(
|
||||
)
|
||||
}
|
||||
|
||||
pub fn canonicalize_record<'a>(
|
||||
env: &mut Env<'a>,
|
||||
var_store: &mut VarStore,
|
||||
scope: &mut Scope,
|
||||
region: Region,
|
||||
fields: ast::Collection<'a, Loc<ast::AssignedField<'a, ast::Expr<'a>>>>,
|
||||
) -> (Expr, Output) {
|
||||
use Expr::*;
|
||||
|
||||
if fields.is_empty() {
|
||||
(EmptyRecord, Output::default())
|
||||
} else {
|
||||
match canonicalize_fields(env, var_store, scope, region, fields.items) {
|
||||
Ok((can_fields, output)) => (
|
||||
Record {
|
||||
record_var: var_store.fresh(),
|
||||
fields: can_fields,
|
||||
},
|
||||
output,
|
||||
),
|
||||
Err(CanonicalizeRecordProblem::InvalidOptionalValue {
|
||||
field_name,
|
||||
field_region,
|
||||
record_region,
|
||||
}) => (
|
||||
Expr::RuntimeError(roc_problem::can::RuntimeError::InvalidOptionalValue {
|
||||
field_name,
|
||||
field_region,
|
||||
record_region,
|
||||
}),
|
||||
Output::default(),
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn canonicalize_closure<'a>(
|
||||
env: &mut Env<'a>,
|
||||
var_store: &mut VarStore,
|
||||
@ -1881,19 +1909,19 @@ fn canonicalize_var_lookup(
|
||||
// Since module_name was empty, this is an unqualified var.
|
||||
// Look it up in scope!
|
||||
match scope.lookup_str(ident, region) {
|
||||
Ok(symbol) => {
|
||||
Ok(lookup) => {
|
||||
output
|
||||
.references
|
||||
.insert_value_lookup(symbol, QualifiedReference::Unqualified);
|
||||
.insert_value_lookup(lookup.symbol, QualifiedReference::Unqualified);
|
||||
|
||||
if scope.abilities_store.is_ability_member_name(symbol) {
|
||||
if scope.abilities_store.is_ability_member_name(lookup.symbol) {
|
||||
AbilityMember(
|
||||
symbol,
|
||||
params_in_abilities_unimplemented!(lookup),
|
||||
Some(scope.abilities_store.fresh_specialization_id()),
|
||||
var_store.fresh(),
|
||||
)
|
||||
} else {
|
||||
Var(symbol, var_store.fresh())
|
||||
lookup_to_expr(lookup, var_store.fresh())
|
||||
}
|
||||
}
|
||||
Err(problem) => {
|
||||
@ -1906,19 +1934,19 @@ fn canonicalize_var_lookup(
|
||||
// Since module_name was nonempty, this is a qualified var.
|
||||
// Look it up in the env!
|
||||
match env.qualified_lookup(scope, module_name, ident, region) {
|
||||
Ok(symbol) => {
|
||||
Ok(lookup) => {
|
||||
output
|
||||
.references
|
||||
.insert_value_lookup(symbol, QualifiedReference::Qualified);
|
||||
.insert_value_lookup(lookup.symbol, QualifiedReference::Qualified);
|
||||
|
||||
if scope.abilities_store.is_ability_member_name(symbol) {
|
||||
if scope.abilities_store.is_ability_member_name(lookup.symbol) {
|
||||
AbilityMember(
|
||||
symbol,
|
||||
params_in_abilities_unimplemented!(lookup),
|
||||
Some(scope.abilities_store.fresh_specialization_id()),
|
||||
var_store.fresh(),
|
||||
)
|
||||
} else {
|
||||
Var(symbol, var_store.fresh())
|
||||
lookup_to_expr(lookup, var_store.fresh())
|
||||
}
|
||||
}
|
||||
Err(problem) => {
|
||||
@ -1936,6 +1964,24 @@ fn canonicalize_var_lookup(
|
||||
(can_expr, output)
|
||||
}
|
||||
|
||||
fn lookup_to_expr(
|
||||
SymbolLookup {
|
||||
symbol,
|
||||
module_params: params,
|
||||
}: SymbolLookup,
|
||||
var: Variable,
|
||||
) -> Expr {
|
||||
if let Some(params) = params {
|
||||
Expr::ParamsVar {
|
||||
symbol,
|
||||
params,
|
||||
var,
|
||||
}
|
||||
} else {
|
||||
Expr::Var(symbol, var)
|
||||
}
|
||||
}
|
||||
|
||||
/// Currently uses the heuristic of "only inline if it's a builtin"
|
||||
pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
|
||||
use Expr::*;
|
||||
@ -1954,6 +2000,7 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
|
||||
| other @ RecordAccessor { .. }
|
||||
| other @ RecordUpdate { .. }
|
||||
| other @ Var(..)
|
||||
| other @ ParamsVar { .. }
|
||||
| other @ AbilityMember(..)
|
||||
| other @ RunLowLevel { .. }
|
||||
| other @ TypedHole { .. }
|
||||
@ -2217,6 +2264,14 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
|
||||
);
|
||||
}
|
||||
|
||||
ImportParams(module_id, region, Some((var, expr))) => ImportParams(
|
||||
module_id,
|
||||
region,
|
||||
Some((var, Box::new(inline_calls(var_store, *expr)))),
|
||||
),
|
||||
|
||||
ImportParams(module_id, region, None) => ImportParams(module_id, region, None),
|
||||
|
||||
RecordAccess {
|
||||
record_var,
|
||||
ext_var,
|
||||
@ -3141,6 +3196,11 @@ pub(crate) fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
|
||||
while let Some(expr) = stack.pop() {
|
||||
match expr {
|
||||
Expr::Var(symbol, var)
|
||||
| Expr::ParamsVar {
|
||||
symbol,
|
||||
params: _,
|
||||
var,
|
||||
}
|
||||
| Expr::RecordUpdate {
|
||||
symbol,
|
||||
record_var: var,
|
||||
@ -3245,6 +3305,9 @@ pub(crate) fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
|
||||
Expr::Tuple { elems, .. } => {
|
||||
stack.extend(elems.iter().map(|(_, elem)| &elem.value));
|
||||
}
|
||||
Expr::ImportParams(_, _, Some((_, expr))) => {
|
||||
stack.push(expr);
|
||||
}
|
||||
Expr::Expect {
|
||||
loc_continuation, ..
|
||||
}
|
||||
@ -3271,6 +3334,7 @@ pub(crate) fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
|
||||
| Expr::EmptyRecord
|
||||
| Expr::TypedHole(_)
|
||||
| Expr::RuntimeError(_)
|
||||
| Expr::ImportParams(_, _, None)
|
||||
| Expr::OpaqueWrapFunction(_) => {}
|
||||
}
|
||||
}
|
||||
|
@ -6,9 +6,11 @@ use crate::def::{canonicalize_defs, report_unused_imports, Def};
|
||||
use crate::effect_module::HostedGeneratedFunctions;
|
||||
use crate::env::Env;
|
||||
use crate::expr::{
|
||||
ClosureData, DbgLookup, Declarations, ExpectLookup, Expr, Output, PendingDerives,
|
||||
AnnotatedMark, ClosureData, DbgLookup, Declarations, ExpectLookup, Expr, Output, PendingDerives,
|
||||
};
|
||||
use crate::pattern::{
|
||||
canonicalize_record_destructure, BindingsFromPattern, Pattern, PermitShadows,
|
||||
};
|
||||
use crate::pattern::{BindingsFromPattern, Pattern};
|
||||
use crate::procedure::References;
|
||||
use crate::scope::Scope;
|
||||
use bumpalo::Bump;
|
||||
@ -18,7 +20,7 @@ use roc_module::ident::Ident;
|
||||
use roc_module::ident::Lowercase;
|
||||
use roc_module::symbol::{IdentIds, IdentIdsByModule, ModuleId, PackageModuleIds, Symbol};
|
||||
use roc_parse::ast::{Defs, TypeAnnotation};
|
||||
use roc_parse::header::HeaderType;
|
||||
use roc_parse::header::{HeaderType, ModuleParams};
|
||||
use roc_parse::pattern::PatternType;
|
||||
use roc_problem::can::{Problem, RuntimeError};
|
||||
use roc_region::all::{Loc, Region};
|
||||
@ -136,6 +138,7 @@ pub struct Module {
|
||||
pub abilities_store: PendingAbilitiesStore,
|
||||
pub loc_expects: VecMap<Region, Vec<ExpectLookup>>,
|
||||
pub loc_dbgs: VecMap<Symbol, DbgLookup>,
|
||||
pub params_pattern: Option<(Variable, AnnotatedMark, Loc<Pattern>)>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
@ -149,6 +152,7 @@ pub struct RigidVariables {
|
||||
pub struct ModuleOutput {
|
||||
pub aliases: MutMap<Symbol, Alias>,
|
||||
pub rigid_variables: RigidVariables,
|
||||
pub params_pattern: Option<(Variable, AnnotatedMark, Loc<Pattern>)>,
|
||||
pub declarations: Declarations,
|
||||
pub exposed_imports: MutMap<Symbol, Region>,
|
||||
pub exposed_symbols: VecSet<Symbol>,
|
||||
@ -244,6 +248,7 @@ impl GeneratedInfo {
|
||||
generates_with,
|
||||
name: _,
|
||||
exposes: _,
|
||||
opt_params: _,
|
||||
} => {
|
||||
debug_assert!(generates_with.is_empty());
|
||||
GeneratedInfo::Builtin
|
||||
@ -274,7 +279,7 @@ fn has_no_implementation(expr: &Expr) -> bool {
|
||||
pub fn canonicalize_module_defs<'a>(
|
||||
arena: &'a Bump,
|
||||
loc_defs: &'a mut Defs<'a>,
|
||||
header_type: &roc_parse::header::HeaderType,
|
||||
header_type: &'a roc_parse::header::HeaderType,
|
||||
home: ModuleId,
|
||||
module_path: &'a str,
|
||||
src: &'a str,
|
||||
@ -290,6 +295,7 @@ pub fn canonicalize_module_defs<'a>(
|
||||
opt_shorthand: Option<&'a str>,
|
||||
) -> ModuleOutput {
|
||||
let mut can_exposed_imports = MutMap::default();
|
||||
|
||||
let mut scope = Scope::new(
|
||||
home,
|
||||
qualified_module_ids
|
||||
@ -382,9 +388,42 @@ pub fn canonicalize_module_defs<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
let mut output = Output::default();
|
||||
|
||||
let params_pattern = header_type.get_params().as_ref().map(
|
||||
|ModuleParams {
|
||||
pattern,
|
||||
before_arrow: _,
|
||||
after_arrow: _,
|
||||
}| {
|
||||
let can_pattern = canonicalize_record_destructure(
|
||||
&mut env,
|
||||
var_store,
|
||||
&mut scope,
|
||||
&mut output,
|
||||
PatternType::ModuleParams,
|
||||
&pattern.value,
|
||||
pattern.region,
|
||||
PermitShadows(false),
|
||||
);
|
||||
|
||||
let loc_pattern = Loc::at(pattern.region, can_pattern);
|
||||
|
||||
for (symbol, _) in BindingsFromPattern::new(&loc_pattern) {
|
||||
env.top_level_symbols.insert(symbol);
|
||||
}
|
||||
|
||||
(
|
||||
var_store.fresh(),
|
||||
AnnotatedMark::new(var_store),
|
||||
loc_pattern,
|
||||
)
|
||||
},
|
||||
);
|
||||
|
||||
let (defs, output, symbols_introduced, imports_introduced) = canonicalize_defs(
|
||||
&mut env,
|
||||
Output::default(),
|
||||
output,
|
||||
var_store,
|
||||
&mut scope,
|
||||
loc_defs,
|
||||
@ -812,6 +851,7 @@ pub fn canonicalize_module_defs<'a>(
|
||||
scope,
|
||||
aliases,
|
||||
rigid_variables,
|
||||
params_pattern,
|
||||
declarations,
|
||||
referenced_values,
|
||||
exposed_imports: can_exposed_imports,
|
||||
@ -1105,6 +1145,7 @@ fn fix_values_captured_in_closure_expr(
|
||||
| SingleQuote(..)
|
||||
| IngestedFile(..)
|
||||
| Var(..)
|
||||
| ParamsVar { .. }
|
||||
| AbilityMember(..)
|
||||
| EmptyRecord
|
||||
| TypedHole { .. }
|
||||
@ -1216,6 +1257,12 @@ fn fix_values_captured_in_closure_expr(
|
||||
}
|
||||
}
|
||||
|
||||
ImportParams(_, _, Some((_, expr))) => {
|
||||
fix_values_captured_in_closure_expr(expr, no_capture_symbols, closure_captures);
|
||||
}
|
||||
|
||||
ImportParams(_, _, None) => {}
|
||||
|
||||
Tuple { elems, .. } => {
|
||||
for (_var, expr) in elems.iter_mut() {
|
||||
fix_values_captured_in_closure_expr(
|
||||
|
@ -623,132 +623,16 @@ pub fn canonicalize_pattern<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
RecordDestructure(patterns) => {
|
||||
let ext_var = var_store.fresh();
|
||||
let whole_var = var_store.fresh();
|
||||
let mut destructs = Vec::with_capacity(patterns.len());
|
||||
let mut opt_erroneous = None;
|
||||
|
||||
for loc_pattern in patterns.iter() {
|
||||
match loc_pattern.value {
|
||||
Identifier { ident: label } => {
|
||||
match scope.introduce(label.into(), region) {
|
||||
Ok(symbol) => {
|
||||
output.references.insert_bound(symbol);
|
||||
|
||||
destructs.push(Loc {
|
||||
region: loc_pattern.region,
|
||||
value: RecordDestruct {
|
||||
var: var_store.fresh(),
|
||||
label: Lowercase::from(label),
|
||||
symbol,
|
||||
typ: DestructType::Required,
|
||||
},
|
||||
});
|
||||
}
|
||||
Err((shadowed_symbol, shadow, new_symbol)) => {
|
||||
env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
|
||||
original_region: shadowed_symbol.region,
|
||||
shadow: shadow.clone(),
|
||||
kind: ShadowKind::Variable,
|
||||
}));
|
||||
|
||||
// No matter what the other patterns
|
||||
// are, we're definitely shadowed and will
|
||||
// get a runtime exception as soon as we
|
||||
// encounter the first bad pattern.
|
||||
opt_erroneous = Some(Pattern::Shadowed(
|
||||
shadowed_symbol.region,
|
||||
shadow,
|
||||
new_symbol,
|
||||
));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
RequiredField(label, loc_guard) => {
|
||||
// a guard does not introduce the label into scope!
|
||||
let symbol =
|
||||
scope.scopeless_symbol(&Ident::from(label), loc_pattern.region);
|
||||
let can_guard = canonicalize_pattern(
|
||||
RecordDestructure(patterns) => canonicalize_record_destructure(
|
||||
env,
|
||||
var_store,
|
||||
scope,
|
||||
output,
|
||||
pattern_type,
|
||||
&loc_guard.value,
|
||||
loc_guard.region,
|
||||
patterns,
|
||||
region,
|
||||
permit_shadows,
|
||||
);
|
||||
|
||||
destructs.push(Loc {
|
||||
region: loc_pattern.region,
|
||||
value: RecordDestruct {
|
||||
var: var_store.fresh(),
|
||||
label: Lowercase::from(label),
|
||||
symbol,
|
||||
typ: DestructType::Guard(var_store.fresh(), can_guard),
|
||||
},
|
||||
});
|
||||
}
|
||||
OptionalField(label, loc_default) => {
|
||||
// an optional DOES introduce the label into scope!
|
||||
match scope.introduce(label.into(), region) {
|
||||
Ok(symbol) => {
|
||||
let (can_default, expr_output) = canonicalize_expr(
|
||||
env,
|
||||
var_store,
|
||||
scope,
|
||||
loc_default.region,
|
||||
&loc_default.value,
|
||||
);
|
||||
|
||||
// an optional field binds the symbol!
|
||||
output.references.insert_bound(symbol);
|
||||
|
||||
output.union(expr_output);
|
||||
|
||||
destructs.push(Loc {
|
||||
region: loc_pattern.region,
|
||||
value: RecordDestruct {
|
||||
var: var_store.fresh(),
|
||||
label: Lowercase::from(label),
|
||||
symbol,
|
||||
typ: DestructType::Optional(var_store.fresh(), can_default),
|
||||
},
|
||||
});
|
||||
}
|
||||
Err((shadowed_symbol, shadow, new_symbol)) => {
|
||||
env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
|
||||
original_region: shadowed_symbol.region,
|
||||
shadow: shadow.clone(),
|
||||
kind: ShadowKind::Variable,
|
||||
}));
|
||||
|
||||
// No matter what the other patterns
|
||||
// are, we're definitely shadowed and will
|
||||
// get a runtime exception as soon as we
|
||||
// encounter the first bad pattern.
|
||||
opt_erroneous = Some(Pattern::Shadowed(
|
||||
shadowed_symbol.region,
|
||||
shadow,
|
||||
new_symbol,
|
||||
));
|
||||
}
|
||||
};
|
||||
}
|
||||
_ => unreachable!("Any other pattern should have given a parse error"),
|
||||
}
|
||||
}
|
||||
|
||||
// If we encountered an erroneous pattern (e.g. one with shadowing),
|
||||
// use the resulting RuntimeError. Otherwise, return a successful record destructure.
|
||||
opt_erroneous.unwrap_or(Pattern::RecordDestructure {
|
||||
whole_var,
|
||||
ext_var,
|
||||
destructs,
|
||||
})
|
||||
}
|
||||
),
|
||||
|
||||
RequiredField(_name, _loc_pattern) => {
|
||||
unreachable!("should have been handled in RecordDestructure");
|
||||
@ -894,6 +778,144 @@ pub fn canonicalize_pattern<'a>(
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn canonicalize_record_destructure<'a>(
|
||||
env: &mut Env<'a>,
|
||||
var_store: &mut VarStore,
|
||||
scope: &mut Scope,
|
||||
output: &mut Output,
|
||||
pattern_type: PatternType,
|
||||
patterns: &ast::Collection<Loc<ast::Pattern<'a>>>,
|
||||
region: Region,
|
||||
permit_shadows: PermitShadows,
|
||||
) -> Pattern {
|
||||
use ast::Pattern::*;
|
||||
|
||||
let ext_var = var_store.fresh();
|
||||
let whole_var = var_store.fresh();
|
||||
let mut destructs = Vec::with_capacity(patterns.len());
|
||||
let mut opt_erroneous = None;
|
||||
|
||||
for loc_pattern in patterns.iter() {
|
||||
match loc_pattern.value {
|
||||
Identifier { ident: label } => {
|
||||
match scope.introduce(label.into(), region) {
|
||||
Ok(symbol) => {
|
||||
output.references.insert_bound(symbol);
|
||||
|
||||
destructs.push(Loc {
|
||||
region: loc_pattern.region,
|
||||
value: RecordDestruct {
|
||||
var: var_store.fresh(),
|
||||
label: Lowercase::from(label),
|
||||
symbol,
|
||||
typ: DestructType::Required,
|
||||
},
|
||||
});
|
||||
}
|
||||
Err((shadowed_symbol, shadow, new_symbol)) => {
|
||||
env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
|
||||
original_region: shadowed_symbol.region,
|
||||
shadow: shadow.clone(),
|
||||
kind: ShadowKind::Variable,
|
||||
}));
|
||||
|
||||
// No matter what the other patterns
|
||||
// are, we're definitely shadowed and will
|
||||
// get a runtime exception as soon as we
|
||||
// encounter the first bad pattern.
|
||||
opt_erroneous = Some(Pattern::Shadowed(
|
||||
shadowed_symbol.region,
|
||||
shadow,
|
||||
new_symbol,
|
||||
));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
RequiredField(label, loc_guard) => {
|
||||
// a guard does not introduce the label into scope!
|
||||
let symbol = scope.scopeless_symbol(&Ident::from(label), loc_pattern.region);
|
||||
let can_guard = canonicalize_pattern(
|
||||
env,
|
||||
var_store,
|
||||
scope,
|
||||
output,
|
||||
pattern_type,
|
||||
&loc_guard.value,
|
||||
loc_guard.region,
|
||||
permit_shadows,
|
||||
);
|
||||
|
||||
destructs.push(Loc {
|
||||
region: loc_pattern.region,
|
||||
value: RecordDestruct {
|
||||
var: var_store.fresh(),
|
||||
label: Lowercase::from(label),
|
||||
symbol,
|
||||
typ: DestructType::Guard(var_store.fresh(), can_guard),
|
||||
},
|
||||
});
|
||||
}
|
||||
OptionalField(label, loc_default) => {
|
||||
// an optional DOES introduce the label into scope!
|
||||
match scope.introduce(label.into(), region) {
|
||||
Ok(symbol) => {
|
||||
let (can_default, expr_output) = canonicalize_expr(
|
||||
env,
|
||||
var_store,
|
||||
scope,
|
||||
loc_default.region,
|
||||
&loc_default.value,
|
||||
);
|
||||
|
||||
// an optional field binds the symbol!
|
||||
output.references.insert_bound(symbol);
|
||||
|
||||
output.union(expr_output);
|
||||
|
||||
destructs.push(Loc {
|
||||
region: loc_pattern.region,
|
||||
value: RecordDestruct {
|
||||
var: var_store.fresh(),
|
||||
label: Lowercase::from(label),
|
||||
symbol,
|
||||
typ: DestructType::Optional(var_store.fresh(), can_default),
|
||||
},
|
||||
});
|
||||
}
|
||||
Err((shadowed_symbol, shadow, new_symbol)) => {
|
||||
env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
|
||||
original_region: shadowed_symbol.region,
|
||||
shadow: shadow.clone(),
|
||||
kind: ShadowKind::Variable,
|
||||
}));
|
||||
|
||||
// No matter what the other patterns
|
||||
// are, we're definitely shadowed and will
|
||||
// get a runtime exception as soon as we
|
||||
// encounter the first bad pattern.
|
||||
opt_erroneous = Some(Pattern::Shadowed(
|
||||
shadowed_symbol.region,
|
||||
shadow,
|
||||
new_symbol,
|
||||
));
|
||||
}
|
||||
};
|
||||
}
|
||||
_ => unreachable!("Any other pattern should have given a parse error"),
|
||||
}
|
||||
}
|
||||
|
||||
// If we encountered an erroneous pattern (e.g. one with shadowing),
|
||||
// use the resulting RuntimeError. Otherwise, return a successful record destructure.
|
||||
opt_erroneous.unwrap_or(Pattern::RecordDestructure {
|
||||
whole_var,
|
||||
ext_var,
|
||||
destructs,
|
||||
})
|
||||
}
|
||||
|
||||
/// When we detect an unsupported pattern type (e.g. 5 = 1 + 2 is unsupported because you can't
|
||||
/// assign to Int patterns), report it to Env and return an UnsupportedPattern runtime error pattern.
|
||||
fn unsupported_pattern(env: &mut Env, pattern_type: PatternType, region: Region) -> Pattern {
|
||||
|
@ -1,8 +1,8 @@
|
||||
use roc_collections::{VecMap, VecSet};
|
||||
use roc_error_macros::internal_error;
|
||||
use roc_module::ident::{Ident, ModuleName};
|
||||
use roc_module::symbol::{IdentId, IdentIds, ModuleId, ScopeModules, Symbol};
|
||||
use roc_problem::can::RuntimeError;
|
||||
use roc_module::symbol::{IdentId, IdentIds, ModuleId, ModuleIds, Symbol};
|
||||
use roc_problem::can::{RuntimeError, ScopeModuleSource};
|
||||
use roc_region::all::{Loc, Region};
|
||||
use roc_types::subs::Variable;
|
||||
use roc_types::types::{Alias, AliasKind, AliasVar, Type};
|
||||
@ -76,7 +76,7 @@ impl Scope {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn lookup(&self, ident: &Ident, region: Region) -> Result<Symbol, RuntimeError> {
|
||||
pub fn lookup(&self, ident: &Ident, region: Region) -> Result<SymbolLookup, RuntimeError> {
|
||||
self.lookup_str(ident.as_str(), region)
|
||||
}
|
||||
|
||||
@ -91,7 +91,7 @@ impl Scope {
|
||||
.push(("Set".into(), Symbol::SET_SET, Region::zero()));
|
||||
}
|
||||
|
||||
pub fn lookup_str(&self, ident: &str, region: Region) -> Result<Symbol, RuntimeError> {
|
||||
pub fn lookup_str(&self, ident: &str, region: Region) -> Result<SymbolLookup, RuntimeError> {
|
||||
use ContainsIdent::*;
|
||||
|
||||
match self.scope_contains_ident(ident) {
|
||||
@ -205,15 +205,20 @@ impl Scope {
|
||||
}
|
||||
}
|
||||
|
||||
fn has_imported_symbol(&self, ident: &str) -> Option<(Symbol, Region)> {
|
||||
for (import, shadow, original_region) in self.imported_symbols.iter() {
|
||||
fn has_imported_symbol(&self, ident: &str) -> Option<(SymbolLookup, Region)> {
|
||||
self.imported_symbols
|
||||
.iter()
|
||||
.find_map(|(import, symbol, original_region)| {
|
||||
if ident == import.as_str() {
|
||||
return Some((*shadow, *original_region));
|
||||
match self.modules.lookup_by_id(&symbol.module_id()) {
|
||||
Some(module) => Some((module.into_symbol(*symbol), *original_region)),
|
||||
None => Some((SymbolLookup::no_params(*symbol), *original_region)),
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Is an identifier in scope, either in the locals or imports
|
||||
fn scope_contains_ident(&self, ident: &str) -> ContainsIdent {
|
||||
@ -229,7 +234,7 @@ impl Scope {
|
||||
ContainsIdent::InScope(original_symbol, original_region) => {
|
||||
// the ident is already in scope; up to the caller how to handle that
|
||||
// (usually it's shadowing, but it is valid to shadow ability members)
|
||||
Err((original_symbol, original_region))
|
||||
Err((original_symbol.symbol, original_region))
|
||||
}
|
||||
ContainsIdent::NotPresent => {
|
||||
// We know nothing about this ident yet; introduce it to the scope
|
||||
@ -389,7 +394,13 @@ impl Scope {
|
||||
region: Region,
|
||||
) -> Result<(), (Symbol, Region)> {
|
||||
match self.scope_contains_ident(ident.as_str()) {
|
||||
ContainsIdent::InScope(symbol, region) => Err((symbol, region)),
|
||||
ContainsIdent::InScope(
|
||||
SymbolLookup {
|
||||
symbol,
|
||||
module_params: _,
|
||||
},
|
||||
region,
|
||||
) => Err((symbol, region)),
|
||||
ContainsIdent::NotPresent | ContainsIdent::NotInScope(_) => {
|
||||
self.imported_symbols.push((ident, symbol, region));
|
||||
Ok(())
|
||||
@ -534,7 +545,7 @@ pub fn create_alias(
|
||||
|
||||
#[derive(Debug)]
|
||||
enum ContainsIdent {
|
||||
InScope(Symbol, Region),
|
||||
InScope(SymbolLookup, Region),
|
||||
NotInScope(IdentId),
|
||||
NotPresent,
|
||||
}
|
||||
@ -561,7 +572,7 @@ impl ScopedIdentIds {
|
||||
|
||||
fn has_in_scope(&self, ident: &Ident) -> Option<(Symbol, Region)> {
|
||||
match self.contains_ident(ident.as_str()) {
|
||||
ContainsIdent::InScope(symbol, region) => Some((symbol, region)),
|
||||
ContainsIdent::InScope(symbol, region) => Some((symbol.symbol, region)),
|
||||
ContainsIdent::NotInScope(_) | ContainsIdent::NotPresent => None,
|
||||
}
|
||||
}
|
||||
@ -574,7 +585,10 @@ impl ScopedIdentIds {
|
||||
for ident_id in self.ident_ids.get_id_many(ident) {
|
||||
let index = ident_id.index();
|
||||
if self.in_scope[index] {
|
||||
return InScope(Symbol::new(self.home, ident_id), self.regions[index]);
|
||||
return InScope(
|
||||
SymbolLookup::no_params(Symbol::new(self.home, ident_id)),
|
||||
self.regions[index],
|
||||
);
|
||||
} else {
|
||||
result = NotInScope(ident_id)
|
||||
}
|
||||
@ -646,6 +660,149 @@ impl ScopedIdentIds {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ScopeModules {
|
||||
/// The ids of all modules in scope
|
||||
ids: Vec<ModuleId>,
|
||||
/// The alias or original name of each module in scope
|
||||
names: Vec<ModuleName>,
|
||||
/// Why is this module in scope?
|
||||
sources: Vec<ScopeModuleSource>,
|
||||
/// The params of a module if any
|
||||
params: Vec<Option<Symbol>>,
|
||||
}
|
||||
|
||||
impl ScopeModules {
|
||||
pub fn new(home_id: ModuleId, home_name: ModuleName) -> Self {
|
||||
let builtins = ModuleIds::default();
|
||||
let builtins_iter = builtins.iter();
|
||||
let count = builtins_iter.len();
|
||||
|
||||
let mut ids = Vec::with_capacity(count + 1);
|
||||
let mut names = Vec::with_capacity(count + 1);
|
||||
let mut sources = vec![ScopeModuleSource::Builtin; count];
|
||||
let mut params = vec![None; count];
|
||||
|
||||
for (module_id, module_name) in builtins_iter {
|
||||
ids.push(module_id);
|
||||
names.push(module_name.clone());
|
||||
}
|
||||
|
||||
if !home_id.is_builtin() {
|
||||
ids.push(home_id);
|
||||
names.push(home_name);
|
||||
sources.push(ScopeModuleSource::Current);
|
||||
params.push(None);
|
||||
}
|
||||
|
||||
Self {
|
||||
ids,
|
||||
names,
|
||||
sources,
|
||||
params,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn lookup(&self, module_name: &ModuleName) -> Option<ModuleLookup> {
|
||||
self.names
|
||||
.iter()
|
||||
.position(|name| name == module_name)
|
||||
.map(|index| ModuleLookup {
|
||||
id: self.ids[index],
|
||||
params: self.params[index],
|
||||
})
|
||||
}
|
||||
|
||||
pub fn lookup_by_id(&self, module_id: &ModuleId) -> Option<ModuleLookup> {
|
||||
self.ids
|
||||
.iter()
|
||||
.position(|id| id == module_id)
|
||||
.map(|index| ModuleLookup {
|
||||
id: self.ids[index],
|
||||
params: self.params[index],
|
||||
})
|
||||
}
|
||||
|
||||
pub fn available_names(&self) -> impl Iterator<Item = &ModuleName> {
|
||||
self.names.iter()
|
||||
}
|
||||
|
||||
pub fn insert(
|
||||
&mut self,
|
||||
module_name: ModuleName,
|
||||
module_id: ModuleId,
|
||||
params_symbol: Option<Symbol>,
|
||||
region: Region,
|
||||
) -> Result<(), ScopeModuleSource> {
|
||||
if let Some(index) = self.names.iter().position(|name| name == &module_name) {
|
||||
if self.ids[index] == module_id {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
return Err(self.sources[index]);
|
||||
}
|
||||
|
||||
self.ids.push(module_id);
|
||||
self.names.push(module_name);
|
||||
self.sources.push(ScopeModuleSource::Import(region));
|
||||
self.params.push(params_symbol);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
debug_assert_eq!(self.ids.len(), self.names.len());
|
||||
debug_assert_eq!(self.ids.len(), self.sources.len());
|
||||
debug_assert_eq!(self.ids.len(), self.params.len());
|
||||
self.ids.len()
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.ids.is_empty()
|
||||
}
|
||||
|
||||
pub fn truncate(&mut self, len: usize) {
|
||||
self.ids.truncate(len);
|
||||
self.names.truncate(len);
|
||||
self.sources.truncate(len);
|
||||
self.params.truncate(len);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SymbolLookup {
|
||||
pub symbol: Symbol,
|
||||
pub module_params: Option<Symbol>,
|
||||
}
|
||||
|
||||
impl SymbolLookup {
|
||||
pub fn new(symbol: Symbol, params: Option<Symbol>) -> Self {
|
||||
Self {
|
||||
symbol,
|
||||
module_params: params,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn no_params(symbol: Symbol) -> Self {
|
||||
Self::new(symbol, None)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ModuleLookup {
|
||||
pub id: ModuleId,
|
||||
pub params: Option<Symbol>,
|
||||
}
|
||||
|
||||
impl ModuleLookup {
|
||||
pub fn into_symbol(&self, symbol: Symbol) -> SymbolLookup {
|
||||
debug_assert_eq!(symbol.module_id(), self.id);
|
||||
|
||||
SymbolLookup {
|
||||
symbol,
|
||||
module_params: self.params,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
@ -701,7 +858,7 @@ mod test {
|
||||
|
||||
let lookup = scope.lookup(&ident, Region::zero()).unwrap();
|
||||
|
||||
assert_eq!(first, lookup);
|
||||
assert_eq!(first, lookup.symbol);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -857,6 +1014,6 @@ mod test {
|
||||
|
||||
let lookup = scope.lookup(&ident, Region::zero()).unwrap();
|
||||
|
||||
assert_eq!(symbol, lookup);
|
||||
assert_eq!(symbol, lookup.symbol);
|
||||
}
|
||||
}
|
||||
|
@ -266,6 +266,7 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr, var: Variable) {
|
||||
walk_list(visitor, *elem_var, loc_elems);
|
||||
}
|
||||
Expr::Var(..) => { /* terminal */ }
|
||||
Expr::ParamsVar { .. } => { /* terminal */ }
|
||||
Expr::AbilityMember(..) => { /* terminal */ }
|
||||
Expr::If {
|
||||
cond_var,
|
||||
@ -317,6 +318,8 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr, var: Variable) {
|
||||
.iter()
|
||||
.for_each(|(var, elem)| visitor.visit_expr(&elem.value, elem.region, *var)),
|
||||
Expr::EmptyRecord => { /* terminal */ }
|
||||
Expr::ImportParams(_, region, Some((_, expr))) => visitor.visit_expr(expr, *region, var),
|
||||
Expr::ImportParams(_, _, None) => { /* terminal */ }
|
||||
Expr::RecordAccess {
|
||||
field_var,
|
||||
loc_expr,
|
||||
|
@ -566,7 +566,12 @@ pub fn constrain_expr(
|
||||
|
||||
constraints.exists([*ret_var], and)
|
||||
}
|
||||
Var(symbol, variable) => {
|
||||
Var(symbol, variable)
|
||||
| ParamsVar {
|
||||
symbol,
|
||||
params: _,
|
||||
var: variable,
|
||||
} => {
|
||||
// Save the expectation in the variable, then lookup the symbol's type in the environment
|
||||
let expected_type = *constraints[expected].get_type_ref();
|
||||
let store_expected = constraints.store(expected_type, *variable, file!(), line!());
|
||||
@ -575,6 +580,22 @@ pub fn constrain_expr(
|
||||
|
||||
constraints.and_constraint([store_expected, lookup_constr])
|
||||
}
|
||||
ImportParams(module_id, region, Some((var, params))) => {
|
||||
let index = constraints.push_variable(*var);
|
||||
let expected_params = constraints.push_expected_type(Expected::ForReason(
|
||||
Reason::ImportParams(*module_id),
|
||||
index,
|
||||
*region,
|
||||
));
|
||||
let expr_con =
|
||||
constrain_expr(types, constraints, env, *region, params, expected_params);
|
||||
let params_con = constraints.import_params(Some(index), *module_id, *region);
|
||||
let expr_and_params = constraints.and_constraint([expr_con, params_con]);
|
||||
constraints.exists([*var], expr_and_params)
|
||||
}
|
||||
ImportParams(module_id, region, None) => {
|
||||
constraints.import_params(None, *module_id, *region)
|
||||
}
|
||||
&AbilityMember(symbol, specialization_id, specialization_var) => {
|
||||
// Save the expectation in the `specialization_var` so we know what to specialize, then
|
||||
// lookup the member in the environment.
|
||||
@ -4089,6 +4110,8 @@ fn is_generalizable_expr(mut expr: &Expr) -> bool {
|
||||
return true;
|
||||
}
|
||||
OpaqueRef { argument, .. } => expr = &argument.1.value,
|
||||
ImportParams(_, _, Some((_, params))) => expr = params,
|
||||
ImportParams(_, _, None) => return false,
|
||||
Str(_)
|
||||
| IngestedFile(..)
|
||||
| List { .. }
|
||||
@ -4115,7 +4138,8 @@ fn is_generalizable_expr(mut expr: &Expr) -> bool {
|
||||
| ZeroArgumentTag { .. }
|
||||
| Tag { .. }
|
||||
| AbilityMember(..)
|
||||
| Var(..) => return false,
|
||||
| Var(..)
|
||||
| ParamsVar { .. } => return false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,11 +1,15 @@
|
||||
use crate::expr::{constrain_def_make_constraint, constrain_def_pattern, Env};
|
||||
use crate::pattern::{constrain_pattern, PatternState};
|
||||
use roc_can::abilities::{PendingAbilitiesStore, PendingMemberType};
|
||||
use roc_can::constraint::{Constraint, Constraints, Generalizable};
|
||||
use roc_can::expected::Expected;
|
||||
use roc_can::expr::Declarations;
|
||||
use roc_can::expected::{Expected, PExpected};
|
||||
use roc_can::expr::{AnnotatedMark, Declarations};
|
||||
use roc_can::pattern::Pattern;
|
||||
use roc_collections::MutMap;
|
||||
use roc_error_macros::internal_error;
|
||||
use roc_module::symbol::{ModuleId, Symbol};
|
||||
use roc_region::all::{Loc, Region};
|
||||
use roc_types::subs::Variable;
|
||||
use roc_types::types::{AnnotationSource, Category, Type, Types};
|
||||
|
||||
pub fn constrain_module(
|
||||
@ -14,9 +18,18 @@ pub fn constrain_module(
|
||||
symbols_from_requires: Vec<(Loc<Symbol>, Loc<Type>)>,
|
||||
abilities_store: &PendingAbilitiesStore,
|
||||
declarations: &Declarations,
|
||||
params_pattern: &Option<(Variable, AnnotatedMark, Loc<Pattern>)>,
|
||||
home: ModuleId,
|
||||
) -> Constraint {
|
||||
let constraint = crate::expr::constrain_decls(types, constraints, home, declarations);
|
||||
|
||||
let constraint = match params_pattern {
|
||||
Some(params_pattern) => {
|
||||
constrain_params(types, constraints, home, constraint, params_pattern)
|
||||
}
|
||||
None => constraint,
|
||||
};
|
||||
|
||||
let constraint = constrain_symbols_from_requires(
|
||||
types,
|
||||
constraints,
|
||||
@ -33,6 +46,63 @@ pub fn constrain_module(
|
||||
constraint
|
||||
}
|
||||
|
||||
fn constrain_params(
|
||||
types: &mut Types,
|
||||
constraints: &mut Constraints,
|
||||
home: ModuleId,
|
||||
constraint: Constraint,
|
||||
(pattern_var, _, loc_pattern): &(Variable, AnnotatedMark, Loc<Pattern>),
|
||||
) -> Constraint {
|
||||
let mut env = Env {
|
||||
home,
|
||||
rigids: MutMap::default(),
|
||||
resolutions_to_make: vec![],
|
||||
};
|
||||
|
||||
let index = constraints.push_variable(*pattern_var);
|
||||
let expected_params = constraints.push_pat_expected_type(PExpected::NoExpectation(index));
|
||||
|
||||
let mut state = PatternState::default();
|
||||
|
||||
let closed_con = match loc_pattern.value {
|
||||
Pattern::RecordDestructure {
|
||||
whole_var: _,
|
||||
ext_var,
|
||||
destructs: _,
|
||||
} => {
|
||||
// Disallow record extension for module params
|
||||
let empty_rec = constraints.push_type(types, Types::EMPTY_RECORD);
|
||||
constraints.store(empty_rec, ext_var, file!(), line!())
|
||||
}
|
||||
_ => internal_error!("Only record destructures are allowed in module params. This should've been caught earlier."),
|
||||
};
|
||||
|
||||
state.constraints.push(closed_con);
|
||||
|
||||
constrain_pattern(
|
||||
types,
|
||||
constraints,
|
||||
&mut env,
|
||||
&loc_pattern.value,
|
||||
loc_pattern.region,
|
||||
expected_params,
|
||||
&mut state,
|
||||
);
|
||||
|
||||
let pattern_constraints = constraints.and_constraint(state.constraints);
|
||||
|
||||
let cons = constraints.let_constraint(
|
||||
[],
|
||||
state.vars,
|
||||
state.headers,
|
||||
pattern_constraints,
|
||||
constraint,
|
||||
Generalizable(true),
|
||||
);
|
||||
|
||||
constraints.exists([*pattern_var], cons)
|
||||
}
|
||||
|
||||
fn constrain_symbols_from_requires(
|
||||
types: &mut Types,
|
||||
constraints: &mut Constraints,
|
||||
|
@ -252,14 +252,14 @@ impl<'a> Formattable for ModuleImportParams<'a> {
|
||||
fn is_multiline(&self) -> bool {
|
||||
let ModuleImportParams { before, params } = self;
|
||||
|
||||
!before.is_empty() || is_collection_multiline(params)
|
||||
!before.is_empty() || is_collection_multiline(¶ms.value)
|
||||
}
|
||||
|
||||
fn format_with_options(&self, buf: &mut Buf, _parens: Parens, newlines: Newlines, indent: u16) {
|
||||
let ModuleImportParams { before, params } = self;
|
||||
|
||||
fmt_default_spaces(buf, before, indent);
|
||||
fmt_collection(buf, indent, Braces::Curly, *params, newlines);
|
||||
fmt_collection(buf, indent, Braces::Curly, params.value, newlines);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -174,11 +174,17 @@ pub fn fmt_module_header<'a>(buf: &mut Buf, header: &'a ModuleHeader<'a>) {
|
||||
let mut indent = fmt_spaces_with_outdent(buf, header.after_keyword, 0);
|
||||
|
||||
if let Some(params) = &header.params {
|
||||
if is_collection_multiline(¶ms.params) {
|
||||
if is_collection_multiline(¶ms.pattern.value) {
|
||||
indent = INDENT;
|
||||
}
|
||||
|
||||
fmt_collection(buf, indent, Braces::Curly, params.params, Newlines::Yes);
|
||||
fmt_collection(
|
||||
buf,
|
||||
indent,
|
||||
Braces::Curly,
|
||||
params.pattern.value,
|
||||
Newlines::Yes,
|
||||
);
|
||||
|
||||
indent = fmt_spaces_with_outdent(buf, params.before_arrow, indent);
|
||||
buf.push_str("->");
|
||||
|
@ -51,6 +51,8 @@ pub fn infer_expr(
|
||||
exposed_by_module: &Default::default(),
|
||||
derived_module,
|
||||
function_kind: FunctionKind::LambdaSet,
|
||||
params_pattern: None,
|
||||
module_params_vars: Default::default(),
|
||||
#[cfg(debug_assertions)]
|
||||
checkmate: None,
|
||||
};
|
||||
|
@ -2395,6 +2395,13 @@ fn update<'a>(
|
||||
.pending_abilities
|
||||
.insert(module_id, constrained_module.module.abilities_store.clone());
|
||||
|
||||
if let Some(params_pattern) = constrained_module.module.params_pattern.clone() {
|
||||
state
|
||||
.module_cache
|
||||
.param_patterns
|
||||
.insert(module_id, params_pattern);
|
||||
}
|
||||
|
||||
state
|
||||
.module_cache
|
||||
.constrained
|
||||
@ -3551,6 +3558,7 @@ fn load_builtin_module_help<'a>(
|
||||
name: header::ModuleName::new(name_stem),
|
||||
exposes: unspace(arena, header.exposes.items),
|
||||
generates_with: &[],
|
||||
opt_params: header.params,
|
||||
},
|
||||
module_comments: comments,
|
||||
header_imports: header.interface_imports,
|
||||
@ -3837,6 +3845,7 @@ fn parse_header<'a>(
|
||||
header_type: HeaderType::Module {
|
||||
name: roc_parse::header::ModuleName::new(module_name),
|
||||
exposes: unspace(arena, header.exposes.items),
|
||||
opt_params: header.params,
|
||||
},
|
||||
module_comments: comments,
|
||||
header_imports: header.interface_imports,
|
||||
@ -4380,7 +4389,7 @@ pub fn add_imports(
|
||||
def_types: &mut Vec<(Symbol, Loc<TypeOrVar>)>,
|
||||
imported_rigid_vars: &mut Vec<Variable>,
|
||||
imported_flex_vars: &mut Vec<Variable>,
|
||||
) -> (Vec<Variable>, AbilitiesStore) {
|
||||
) -> (Vec<Variable>, VecMap<ModuleId, Variable>, AbilitiesStore) {
|
||||
let mut import_variables = Vec::new();
|
||||
|
||||
let mut cached_symbol_vars = VecMap::default();
|
||||
@ -4487,7 +4496,31 @@ pub fn add_imports(
|
||||
},
|
||||
);
|
||||
|
||||
(import_variables, abilities_store)
|
||||
let mut imported_param_vars = VecMap::default();
|
||||
|
||||
for (module_id, _) in exposed_for_module.exposed_by_module.iter_all() {
|
||||
let ExposedModuleTypes {
|
||||
exposed_types_storage_subs: exposed_types,
|
||||
..
|
||||
} = exposed_for_module.exposed_by_module.get(module_id).unwrap();
|
||||
|
||||
if let Some(stored_aprams_var) = exposed_types.stored_params_var {
|
||||
let copied_import = exposed_types
|
||||
.storage_subs
|
||||
.export_variable_to(subs, stored_aprams_var);
|
||||
|
||||
let copied_import_var = extend_imports_data_with_copied_import(
|
||||
copied_import,
|
||||
&mut import_variables,
|
||||
imported_rigid_vars,
|
||||
imported_flex_vars,
|
||||
);
|
||||
|
||||
imported_param_vars.insert(*module_id, copied_import_var);
|
||||
}
|
||||
}
|
||||
|
||||
(import_variables, imported_param_vars, abilities_store)
|
||||
}
|
||||
|
||||
enum OnSymbolNotFound {
|
||||
@ -4609,6 +4642,7 @@ fn run_solve_solve(
|
||||
aliases,
|
||||
rigid_variables,
|
||||
abilities_store: pending_abilities,
|
||||
params_pattern,
|
||||
..
|
||||
} = module;
|
||||
|
||||
@ -4618,7 +4652,7 @@ fn run_solve_solve(
|
||||
|
||||
let mut subs = Subs::new_from_varstore(var_store);
|
||||
|
||||
let (import_variables, abilities_store) = add_imports(
|
||||
let (import_variables, imported_param_vars, abilities_store) = add_imports(
|
||||
module.module_id,
|
||||
&mut constraints,
|
||||
&mut subs,
|
||||
@ -4656,6 +4690,8 @@ fn run_solve_solve(
|
||||
derived_module,
|
||||
#[cfg(debug_assertions)]
|
||||
checkmate,
|
||||
params_pattern: params_pattern.map(|(_, _, pattern)| pattern.value),
|
||||
module_params_vars: imported_param_vars,
|
||||
};
|
||||
|
||||
let solve_output = roc_solve::module::run_solve(
|
||||
@ -4740,6 +4776,11 @@ fn run_solve<'a>(
|
||||
// TODO remove when we write builtins in roc
|
||||
let aliases = module.aliases.clone();
|
||||
|
||||
let opt_params_var = module
|
||||
.params_pattern
|
||||
.as_ref()
|
||||
.map(|(params_var, _, _)| *params_var);
|
||||
|
||||
let mut module = module;
|
||||
let loc_expects = std::mem::take(&mut module.loc_expects);
|
||||
let loc_dbgs = std::mem::take(&mut module.loc_dbgs);
|
||||
@ -4811,6 +4852,7 @@ fn run_solve<'a>(
|
||||
module_id,
|
||||
&mut solved_subs,
|
||||
&exposed_vars_by_symbol,
|
||||
opt_params_var,
|
||||
&solved_implementations,
|
||||
&abilities_store,
|
||||
);
|
||||
@ -5060,6 +5102,7 @@ fn canonicalize_and_constrain<'a>(
|
||||
module_output.symbols_from_requires,
|
||||
&module_output.scope.abilities_store,
|
||||
&module_output.declarations,
|
||||
&module_output.params_pattern,
|
||||
module_id,
|
||||
)
|
||||
};
|
||||
@ -5116,6 +5159,7 @@ fn canonicalize_and_constrain<'a>(
|
||||
abilities_store: module_output.scope.abilities_store,
|
||||
loc_expects: module_output.loc_expects,
|
||||
loc_dbgs: module_output.loc_dbgs,
|
||||
params_pattern: module_output.params_pattern,
|
||||
};
|
||||
|
||||
let constrained_module = ConstrainedModule {
|
||||
@ -5459,6 +5503,7 @@ fn make_specializations<'a>(
|
||||
) -> Msg<'a> {
|
||||
let make_specializations_start = Instant::now();
|
||||
let mut update_mode_ids = UpdateModeIds::new();
|
||||
|
||||
// do the thing
|
||||
let mut mono_env = roc_mono::ir::Env {
|
||||
arena,
|
||||
|
@ -4,12 +4,13 @@ use crate::module::{
|
||||
ModuleHeader, ParsedModule, TypeCheckedModule,
|
||||
};
|
||||
use roc_can::abilities::PendingAbilitiesStore;
|
||||
use roc_can::expr::AnnotatedMark;
|
||||
use roc_collections::{MutMap, MutSet, VecMap};
|
||||
use roc_module::ident::ModuleName;
|
||||
use roc_module::symbol::{ModuleId, PQModuleName, Symbol};
|
||||
use roc_mono::ir::ExternalSpecializations;
|
||||
use roc_problem::Severity;
|
||||
use roc_region::all::Region;
|
||||
use roc_region::all::{Loc, Region};
|
||||
use roc_solve_problem::TypeError;
|
||||
use roc_types::subs::Variable;
|
||||
use roc_types::types::Alias;
|
||||
@ -26,6 +27,8 @@ pub(crate) struct ModuleCache<'a> {
|
||||
pub(crate) aliases: MutMap<ModuleId, MutMap<Symbol, (bool, Alias)>>,
|
||||
pub(crate) pending_abilities: MutMap<ModuleId, PendingAbilitiesStore>,
|
||||
pub(crate) constrained: MutMap<ModuleId, ConstrainedModule>,
|
||||
pub(crate) param_patterns:
|
||||
MutMap<ModuleId, (Variable, AnnotatedMark, Loc<roc_can::pattern::Pattern>)>,
|
||||
pub(crate) typechecked: MutMap<ModuleId, TypeCheckedModule<'a>>,
|
||||
pub(crate) checked: MutMap<ModuleId, CheckedModule>,
|
||||
pub(crate) found_specializations: MutMap<ModuleId, FoundSpecializationsModule<'a>>,
|
||||
@ -100,6 +103,7 @@ impl Default for ModuleCache<'_> {
|
||||
aliases: Default::default(),
|
||||
pending_abilities: Default::default(),
|
||||
constrained: Default::default(),
|
||||
param_patterns: Default::default(),
|
||||
typechecked: Default::default(),
|
||||
checked: Default::default(),
|
||||
found_specializations: Default::default(),
|
||||
|
@ -27,10 +27,11 @@ use roc_module::symbol::{Interns, ModuleId};
|
||||
use roc_packaging::cache::RocCacheDir;
|
||||
use roc_problem::can::Problem;
|
||||
use roc_region::all::LineInfo;
|
||||
use roc_reporting::report::RocDocAllocator;
|
||||
use roc_reporting::report::{can_problem, DEFAULT_PALETTE};
|
||||
use roc_reporting::report::{strip_colors, RenderTarget};
|
||||
use roc_reporting::report::{type_problem, RocDocAllocator};
|
||||
use roc_solve::FunctionKind;
|
||||
use roc_solve_problem::TypeError;
|
||||
use roc_target::Target;
|
||||
use roc_test_utils_dir::TmpDir;
|
||||
use roc_types::pretty_print::name_and_print_var;
|
||||
@ -107,6 +108,33 @@ fn format_can_problems(
|
||||
buf
|
||||
}
|
||||
|
||||
fn format_type_problems(
|
||||
problems: Vec<TypeError>,
|
||||
home: ModuleId,
|
||||
interns: &Interns,
|
||||
filename: PathBuf,
|
||||
src: &str,
|
||||
) -> String {
|
||||
use ven_pretty::DocAllocator;
|
||||
|
||||
let src_lines: Vec<&str> = src.split('\n').collect();
|
||||
let lines = LineInfo::new(src);
|
||||
let alloc = RocDocAllocator::new(&src_lines, home, interns);
|
||||
let reports = problems
|
||||
.into_iter()
|
||||
.flat_map(|problem| type_problem(&alloc, &lines, filename.clone(), problem))
|
||||
.map(|report| report.pretty(&alloc));
|
||||
|
||||
let mut buf = String::new();
|
||||
alloc
|
||||
.stack(reports)
|
||||
.append(alloc.line())
|
||||
.1
|
||||
.render_raw(70, &mut roc_reporting::report::CiWrite::new(&mut buf))
|
||||
.unwrap();
|
||||
buf
|
||||
}
|
||||
|
||||
fn multiple_modules(subdir: &str, files: Vec<(&str, &str)>) -> Result<LoadedModule, String> {
|
||||
let arena = Bump::new();
|
||||
let arena = &arena;
|
||||
@ -130,11 +158,19 @@ fn multiple_modules(subdir: &str, files: Vec<(&str, &str)>) -> Result<LoadedModu
|
||||
));
|
||||
}
|
||||
|
||||
assert!(loaded_module
|
||||
let type_problems = loaded_module
|
||||
.type_problems
|
||||
.remove(&home)
|
||||
.unwrap_or_default()
|
||||
.is_empty(),);
|
||||
.unwrap_or_default();
|
||||
if !type_problems.is_empty() {
|
||||
return Err(format_type_problems(
|
||||
type_problems,
|
||||
home,
|
||||
&loaded_module.interns,
|
||||
filepath.clone(),
|
||||
src,
|
||||
));
|
||||
}
|
||||
|
||||
Ok(loaded_module)
|
||||
}
|
||||
@ -279,6 +315,13 @@ fn expect_types(mut loaded_module: LoadedModule, mut expected_types: HashMap<&st
|
||||
|
||||
match declarations.declarations[index] {
|
||||
Value | Function(_) | Recursive(_) | TailRecursive(_) => {
|
||||
let body = declarations.expressions[index].clone();
|
||||
|
||||
if let roc_can::expr::Expr::ImportParams(_, _, None) = body.value {
|
||||
// Skip import defs without params
|
||||
continue;
|
||||
}
|
||||
|
||||
let symbol = declarations.symbols[index].value;
|
||||
let expr_var = declarations.variables[index];
|
||||
|
||||
@ -407,8 +450,14 @@ fn module_with_deps() {
|
||||
|
||||
match declarations.declarations[index] {
|
||||
Value | Function(_) | Recursive(_) | TailRecursive(_) => {
|
||||
let body = declarations.expressions[index].clone();
|
||||
|
||||
if let roc_can::expr::Expr::ImportParams(_, _, None) = body.value {
|
||||
// Skip import defs without params
|
||||
} else {
|
||||
def_count += 1;
|
||||
}
|
||||
}
|
||||
Destructure(_) => {
|
||||
def_count += 1;
|
||||
}
|
||||
@ -1563,6 +1612,325 @@ fn cannot_use_original_name_if_imported_with_alias() {
|
||||
multiple_modules("cannot_use_original_name_if_imported_with_alias", modules).unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_checks() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module { key } -> [url]
|
||||
|
||||
url = "example.com/$(key)"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api { key: "abcdef" }
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let result = multiple_modules("module_params_checks", modules);
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_optional() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module { key, exp ? "default" } -> [url]
|
||||
|
||||
url = "example.com/$(key)?exp=$(exp)"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api { key: "abcdef" }
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let result = multiple_modules("module_params_optional", modules);
|
||||
assert!(result.is_ok())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_typecheck_fail() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module { key } -> [url]
|
||||
|
||||
url = "example.com/$(key)"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api { key: 123 }
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let result = multiple_modules("module_params_typecheck_fail", modules).unwrap_err();
|
||||
assert_eq!(
|
||||
result,
|
||||
indoc!(
|
||||
r#"
|
||||
── MODULE PARAMS MISMATCH in tmp/module_params_typecheck_fail/Main.roc ─────────
|
||||
|
||||
Something is off with the params provided by this import:
|
||||
|
||||
3│ import Api { key: 123 }
|
||||
^^^^^^^^^^^^
|
||||
|
||||
This is the type I inferred:
|
||||
|
||||
{ key : Num * }
|
||||
|
||||
However, Api expects:
|
||||
|
||||
{ key : Str }
|
||||
"#
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_missing_fields() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module { key } -> [url]
|
||||
|
||||
url = "example.com/$(key)"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api {}
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let result = multiple_modules("module_params_missing_fields", modules).unwrap_err();
|
||||
assert_eq!(
|
||||
result,
|
||||
indoc!(
|
||||
r#"
|
||||
── MODULE PARAMS MISMATCH in tmp/module_params_missing_fields/Main.roc ─────────
|
||||
|
||||
Something is off with the params provided by this import:
|
||||
|
||||
3│ import Api {}
|
||||
^^
|
||||
|
||||
This is the type I inferred:
|
||||
|
||||
{}
|
||||
|
||||
However, Api expects:
|
||||
|
||||
{ key : Str }
|
||||
|
||||
Tip: Looks like the key field is missing.
|
||||
"#
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_extra_fields() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module { key } -> [url]
|
||||
|
||||
url = "example.com/$(key)"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api { key: "123", doesNotExist: Bool.true }
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let result = multiple_modules("module_params_extra_fields", modules).unwrap_err();
|
||||
assert_eq!(
|
||||
result,
|
||||
indoc!(
|
||||
r#"
|
||||
── MODULE PARAMS MISMATCH in tmp/module_params_extra_fields/Main.roc ───────────
|
||||
|
||||
Something is off with the params provided by this import:
|
||||
|
||||
3│ import Api { key: "123", doesNotExist: Bool.true }
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
This is the type I inferred:
|
||||
|
||||
{ doesNotExist : Bool, … }
|
||||
|
||||
However, Api expects:
|
||||
|
||||
{ … }
|
||||
|
||||
|
||||
"#
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_unexpected() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [url]
|
||||
|
||||
url = "example.com"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api { key: 123 }
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let err = multiple_modules("module_params_unexpected", modules).unwrap_err();
|
||||
assert_eq!(
|
||||
err,
|
||||
indoc!(
|
||||
r#"
|
||||
── UNEXPECTED MODULE PARAMS in tmp/module_params_unexpected/Main.roc ───────────
|
||||
|
||||
This import specifies module params:
|
||||
|
||||
3│ import Api { key: 123 }
|
||||
^^^^^^^^^^^^
|
||||
|
||||
However, Api does not expect any. Did you intend to import a different
|
||||
module?
|
||||
"#
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn module_params_missing() {
|
||||
let modules = vec![
|
||||
(
|
||||
"Api.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module { key, exp } -> [url]
|
||||
|
||||
url = "example.com/$(key)?exp=$(Num.toStr exp)"
|
||||
"#
|
||||
),
|
||||
),
|
||||
(
|
||||
"Main.roc",
|
||||
indoc!(
|
||||
r#"
|
||||
module [example]
|
||||
|
||||
import Api
|
||||
|
||||
example = Api.url
|
||||
"#
|
||||
),
|
||||
),
|
||||
];
|
||||
|
||||
let err = multiple_modules("module_params_missing", modules).unwrap_err();
|
||||
assert_eq!(
|
||||
err,
|
||||
indoc!(
|
||||
r#"
|
||||
── MISSING MODULE PARAMS in tmp/module_params_missing/Main.roc ─────────────────
|
||||
|
||||
This import specifies no module params:
|
||||
|
||||
3│ import Api
|
||||
^^^^^^^^^^
|
||||
|
||||
However, Api expects the following to be provided:
|
||||
|
||||
{
|
||||
exp : Num *,
|
||||
key : Str,
|
||||
}
|
||||
|
||||
You can provide params after the module name, like:
|
||||
|
||||
import Menu { echo, read }
|
||||
"#
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn issue_2863_module_type_does_not_exist() {
|
||||
let modules = vec![
|
||||
|
@ -627,67 +627,12 @@ impl ModuleIds {
|
||||
pub fn available_modules(&self) -> impl Iterator<Item = &ModuleName> {
|
||||
self.by_id.iter()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ScopeModules {
|
||||
modules: VecMap<ModuleName, ModuleId>,
|
||||
sources: VecMap<ModuleId, ScopeModuleSource>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ScopeModuleSource {
|
||||
Builtin,
|
||||
Current,
|
||||
Import(Region),
|
||||
}
|
||||
|
||||
impl ScopeModules {
|
||||
pub fn get_id(&self, module_name: &ModuleName) -> Option<ModuleId> {
|
||||
self.modules.get(module_name).copied()
|
||||
}
|
||||
|
||||
pub fn has_id(&self, module_id: ModuleId) -> bool {
|
||||
self.sources.contains_key(&module_id)
|
||||
}
|
||||
|
||||
pub fn available_names(&self) -> impl Iterator<Item = &ModuleName> {
|
||||
self.modules.keys()
|
||||
}
|
||||
|
||||
pub fn insert(
|
||||
&mut self,
|
||||
module_name: ModuleName,
|
||||
module_id: ModuleId,
|
||||
region: Region,
|
||||
) -> Result<(), ScopeModuleSource> {
|
||||
if let Some(existing_module_id) = self.modules.get(&module_name) {
|
||||
if *existing_module_id == module_id {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
return Err(*self.sources.get(existing_module_id).unwrap());
|
||||
}
|
||||
|
||||
self.modules.insert(module_name, module_id);
|
||||
self.sources
|
||||
.insert(module_id, ScopeModuleSource::Import(region));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
debug_assert_eq!(self.modules.len(), self.sources.len());
|
||||
self.modules.len()
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
debug_assert_eq!(self.modules.is_empty(), self.sources.is_empty());
|
||||
self.modules.is_empty()
|
||||
}
|
||||
|
||||
pub fn truncate(&mut self, len: usize) {
|
||||
self.modules.truncate(len);
|
||||
self.sources.truncate(len);
|
||||
pub fn iter(&self) -> impl ExactSizeIterator<Item = (ModuleId, &ModuleName)> {
|
||||
self.by_id
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(index, name)| (ModuleId::from_zero_indexed(index), name))
|
||||
}
|
||||
}
|
||||
|
||||
@ -1031,32 +976,6 @@ macro_rules! define_builtins {
|
||||
}
|
||||
}
|
||||
|
||||
impl ScopeModules {
|
||||
pub fn new(home_id: ModuleId, home_name: ModuleName) -> Self {
|
||||
// +1 because the user will be compiling at least 1 non-builtin module!
|
||||
let capacity = $total + 1;
|
||||
|
||||
let mut modules = VecMap::with_capacity(capacity);
|
||||
let mut sources = VecMap::with_capacity(capacity);
|
||||
|
||||
modules.insert(home_name, home_id);
|
||||
sources.insert(home_id, ScopeModuleSource::Current);
|
||||
|
||||
let mut insert_both = |id: ModuleId, name_str: &'static str| {
|
||||
let name: ModuleName = name_str.into();
|
||||
|
||||
modules.insert(name, id);
|
||||
sources.insert(id, ScopeModuleSource::Builtin);
|
||||
};
|
||||
|
||||
$(
|
||||
insert_both(ModuleId::$module_const, $module_name);
|
||||
)+
|
||||
|
||||
ScopeModules { modules, sources }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Default for PackageModuleIds<'a> {
|
||||
fn default() -> Self {
|
||||
// +1 because the user will be compiling at least 1 non-builtin module!
|
||||
|
@ -4443,6 +4443,15 @@ pub fn with_hole<'a>(
|
||||
|
||||
specialize_naked_symbol(env, variable, procs, layout_cache, assigned, hole, symbol)
|
||||
}
|
||||
ParamsVar { .. } => {
|
||||
unimplemented!("module params code generation")
|
||||
}
|
||||
ImportParams(_, _, Some((_, value))) => {
|
||||
with_hole(env, *value, variable, procs, layout_cache, assigned, hole)
|
||||
}
|
||||
ImportParams(_, _, None) => {
|
||||
internal_error!("Missing module params should've been dropped by now");
|
||||
}
|
||||
AbilityMember(member, specialization_id, specialization_var) => {
|
||||
let specialization_symbol = late_resolve_ability_specialization(
|
||||
env,
|
||||
|
@ -1068,7 +1068,7 @@ impl<'a, 'b> Iterator for RecursiveValueDefIter<'a, 'b> {
|
||||
params,
|
||||
}) => {
|
||||
if let Some(ModuleImportParams { before: _, params }) = params {
|
||||
for loc_assigned_field in params.items {
|
||||
for loc_assigned_field in params.value.items {
|
||||
if let Some(expr) = loc_assigned_field.value.value() {
|
||||
self.push_pending_from_expr(&expr.value);
|
||||
}
|
||||
@ -1116,7 +1116,7 @@ pub struct ModuleImport<'a> {
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub struct ModuleImportParams<'a> {
|
||||
pub before: &'a [CommentOrNewline<'a>],
|
||||
pub params: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
|
||||
pub params: Loc<Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
|
@ -892,10 +892,10 @@ fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<
|
||||
then(
|
||||
and(
|
||||
backtrackable(space0_e(EImportParams::Indent)),
|
||||
specialize_err(EImportParams::Record, record_help()),
|
||||
specialize_err(EImportParams::Record, loc(record_help())),
|
||||
),
|
||||
|arena, state, _, (before, record): (_, RecordHelp<'a>)| {
|
||||
if let Some(prefix) = record.prefix {
|
||||
|arena, state, _, (before, loc_record): (_, Loc<RecordHelp<'a>>)| {
|
||||
if let Some(prefix) = loc_record.value.prefix {
|
||||
match prefix {
|
||||
(update, RecordHelpPrefix::Update) => {
|
||||
return Err((
|
||||
@ -912,7 +912,10 @@ fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<
|
||||
}
|
||||
}
|
||||
|
||||
let params = record.fields.map_items_result(arena, |loc_field| {
|
||||
let params = loc_record
|
||||
.value
|
||||
.fields
|
||||
.map_items_result(arena, |loc_field| {
|
||||
match loc_field.value.to_assigned_field(arena) {
|
||||
Ok(AssignedField::IgnoredValue(_, _, _)) => Err((
|
||||
MadeProgress,
|
||||
@ -926,7 +929,10 @@ fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<
|
||||
}
|
||||
})?;
|
||||
|
||||
let import_params = ModuleImportParams { before, params };
|
||||
let import_params = ModuleImportParams {
|
||||
before,
|
||||
params: Loc::at(loc_record.region, params),
|
||||
};
|
||||
|
||||
Ok((MadeProgress, import_params, state))
|
||||
},
|
||||
|
@ -123,7 +123,7 @@ fn module_header<'a>() -> impl Parser<'a, ModuleHeader<'a>, EHeader<'a>> {
|
||||
|
||||
fn module_params<'a>() -> impl Parser<'a, ModuleParams<'a>, EParams<'a>> {
|
||||
record!(ModuleParams {
|
||||
params: specialize_err(EParams::Pattern, record_pattern_fields()),
|
||||
pattern: specialize_err(EParams::Pattern, loc(record_pattern_fields())),
|
||||
before_arrow: skip_second(
|
||||
space0_e(EParams::BeforeArrow),
|
||||
loc(two_bytes(b'-', b'>', EParams::Arrow))
|
||||
@ -985,6 +985,7 @@ pub enum HeaderType<'a> {
|
||||
name: ModuleName<'a>,
|
||||
exposes: &'a [Loc<ExposedName<'a>>],
|
||||
generates_with: &'a [Symbol],
|
||||
opt_params: Option<ModuleParams<'a>>,
|
||||
},
|
||||
Package {
|
||||
/// usually something other than `pf`
|
||||
@ -1008,6 +1009,7 @@ pub enum HeaderType<'a> {
|
||||
Module {
|
||||
name: ModuleName<'a>,
|
||||
exposes: &'a [Loc<ExposedName<'a>>],
|
||||
opt_params: Option<ModuleParams<'a>>,
|
||||
},
|
||||
}
|
||||
|
||||
@ -1032,12 +1034,57 @@ impl<'a> HeaderType<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_params(&self) -> &Option<ModuleParams<'a>> {
|
||||
match self {
|
||||
Self::Module {
|
||||
opt_params,
|
||||
name: _,
|
||||
exposes: _,
|
||||
}
|
||||
| Self::Builtin {
|
||||
opt_params,
|
||||
name: _,
|
||||
exposes: _,
|
||||
generates_with: _,
|
||||
} => opt_params,
|
||||
Self::App {
|
||||
provides: _,
|
||||
to_platform: _,
|
||||
}
|
||||
| Self::Package {
|
||||
config_shorthand: _,
|
||||
exposes: _,
|
||||
exposes_ids: _,
|
||||
}
|
||||
| Self::Hosted {
|
||||
name: _,
|
||||
exposes: _,
|
||||
generates: _,
|
||||
generates_with: _,
|
||||
}
|
||||
| Self::Platform {
|
||||
opt_app_module_id: _,
|
||||
provides: _,
|
||||
requires: _,
|
||||
requires_types: _,
|
||||
exposes: _,
|
||||
exposes_ids: _,
|
||||
config_shorthand: _,
|
||||
} => &None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_maybe_builtin(self, module_id: ModuleId) -> Self {
|
||||
match self {
|
||||
HeaderType::Module { name, exposes } if module_id.is_builtin() => HeaderType::Builtin {
|
||||
HeaderType::Module {
|
||||
name,
|
||||
exposes,
|
||||
opt_params,
|
||||
} if module_id.is_builtin() => HeaderType::Builtin {
|
||||
name,
|
||||
exposes,
|
||||
generates_with: &[],
|
||||
opt_params,
|
||||
},
|
||||
_ => self,
|
||||
}
|
||||
@ -1185,7 +1232,7 @@ pub struct ModuleHeader<'a> {
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct ModuleParams<'a> {
|
||||
pub params: Collection<'a, Loc<Pattern<'a>>>,
|
||||
pub pattern: Loc<Collection<'a, Loc<Pattern<'a>>>>,
|
||||
pub before_arrow: &'a [CommentOrNewline<'a>],
|
||||
pub after_arrow: &'a [CommentOrNewline<'a>],
|
||||
}
|
||||
|
@ -189,7 +189,7 @@ impl<'a> Normalize<'a> for Header<'a> {
|
||||
impl<'a> Normalize<'a> for ModuleParams<'a> {
|
||||
fn normalize(&self, arena: &'a Bump) -> Self {
|
||||
ModuleParams {
|
||||
params: self.params.normalize(arena),
|
||||
pattern: self.pattern.normalize(arena),
|
||||
before_arrow: &[],
|
||||
after_arrow: &[],
|
||||
}
|
||||
|
@ -25,6 +25,7 @@ pub enum PatternType {
|
||||
DefExpr,
|
||||
FunctionArg,
|
||||
WhenBranch,
|
||||
ModuleParams,
|
||||
}
|
||||
|
||||
pub fn closure_param<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {
|
||||
|
@ -4,7 +4,7 @@ use std::path::PathBuf;
|
||||
use roc_collections::all::MutSet;
|
||||
use roc_module::called_via::BinOp;
|
||||
use roc_module::ident::{Ident, Lowercase, ModuleName, TagName};
|
||||
use roc_module::symbol::{ModuleId, ScopeModuleSource, Symbol};
|
||||
use roc_module::symbol::{ModuleId, Symbol};
|
||||
use roc_parse::ast::Base;
|
||||
use roc_parse::pattern::PatternType;
|
||||
use roc_region::all::{Loc, Region};
|
||||
@ -238,6 +238,13 @@ pub enum Problem {
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ScopeModuleSource {
|
||||
Builtin,
|
||||
Current,
|
||||
Import(Region),
|
||||
}
|
||||
|
||||
impl Problem {
|
||||
pub fn severity(&self) -> Severity {
|
||||
use Severity::{Fatal, RuntimeError, Warning};
|
||||
|
@ -80,6 +80,10 @@ pub struct SolveConfig<'a> {
|
||||
#[cfg(debug_assertions)]
|
||||
/// The checkmate collector for this module.
|
||||
pub checkmate: Option<roc_checkmate::Collector>,
|
||||
|
||||
/// Module params
|
||||
pub params_pattern: Option<roc_can::pattern::Pattern>,
|
||||
pub module_params_vars: VecMap<ModuleId, Variable>,
|
||||
}
|
||||
|
||||
pub struct SolveOutput {
|
||||
@ -144,6 +148,7 @@ pub fn exposed_types_storage_subs(
|
||||
home: ModuleId,
|
||||
solved_subs: &mut Solved<Subs>,
|
||||
exposed_vars_by_symbol: &[(Symbol, Variable)],
|
||||
params_var: Option<Variable>,
|
||||
solved_implementations: &ResolvedImplementations,
|
||||
abilities_store: &AbilitiesStore,
|
||||
) -> ExposedTypesStorageSubs {
|
||||
@ -156,6 +161,9 @@ pub fn exposed_types_storage_subs(
|
||||
stored_vars_by_symbol.insert(*symbol, new_var);
|
||||
}
|
||||
|
||||
let stored_params_var =
|
||||
params_var.map(|params_var| storage_subs.import_variable_from(subs, params_var).variable);
|
||||
|
||||
let mut stored_specialization_lambda_set_vars =
|
||||
VecMap::with_capacity(solved_implementations.len());
|
||||
|
||||
@ -213,6 +221,7 @@ pub fn exposed_types_storage_subs(
|
||||
stored_vars_by_symbol,
|
||||
stored_specialization_lambda_set_vars,
|
||||
stored_ability_member_vars,
|
||||
stored_params_var,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -16,11 +16,12 @@ use roc_can::abilities::{AbilitiesStore, MemberSpecializationInfo};
|
||||
use roc_can::constraint::Constraint::{self, *};
|
||||
use roc_can::constraint::{Cycle, LetConstraint, OpportunisticResolve};
|
||||
use roc_can::expected::{Expected, PExpected};
|
||||
use roc_collections::VecMap;
|
||||
use roc_debug_flags::dbg_do;
|
||||
#[cfg(debug_assertions)]
|
||||
use roc_debug_flags::ROC_VERIFY_RIGID_LET_GENERALIZED;
|
||||
use roc_error_macros::internal_error;
|
||||
use roc_module::symbol::Symbol;
|
||||
use roc_module::symbol::{ModuleId, Symbol};
|
||||
use roc_problem::can::CycleEntry;
|
||||
use roc_region::all::Loc;
|
||||
use roc_solve_problem::TypeError;
|
||||
@ -129,15 +130,13 @@ fn run_help(
|
||||
exposed_by_module,
|
||||
derived_module,
|
||||
function_kind,
|
||||
params_pattern,
|
||||
module_params_vars,
|
||||
..
|
||||
} = config;
|
||||
|
||||
let mut pools = Pools::default();
|
||||
|
||||
let state = State {
|
||||
scope: Scope::default(),
|
||||
mark: Mark::NONE.next(),
|
||||
};
|
||||
let rank = Rank::toplevel();
|
||||
let arena = Bump::new();
|
||||
|
||||
@ -178,7 +177,6 @@ fn run_help(
|
||||
let state = solve(
|
||||
&mut env,
|
||||
types,
|
||||
state,
|
||||
rank,
|
||||
problems,
|
||||
aliases,
|
||||
@ -186,6 +184,8 @@ fn run_help(
|
||||
abilities_store,
|
||||
&mut obligation_cache,
|
||||
&mut awaiting_specializations,
|
||||
params_pattern,
|
||||
module_params_vars,
|
||||
);
|
||||
|
||||
RunSolveOutput {
|
||||
@ -236,7 +236,6 @@ enum Work<'a> {
|
||||
fn solve(
|
||||
env: &mut InferenceEnv,
|
||||
mut can_types: Types,
|
||||
mut state: State,
|
||||
rank: Rank,
|
||||
problems: &mut Vec<TypeError>,
|
||||
aliases: &mut Aliases,
|
||||
@ -244,15 +243,24 @@ fn solve(
|
||||
abilities_store: &mut AbilitiesStore,
|
||||
obligation_cache: &mut ObligationCache,
|
||||
awaiting_specializations: &mut AwaitingSpecializations,
|
||||
params_pattern: Option<roc_can::pattern::Pattern>,
|
||||
module_params_vars: VecMap<ModuleId, Variable>,
|
||||
) -> State {
|
||||
let scope = Scope::new(params_pattern);
|
||||
|
||||
let initial = Work::Constraint {
|
||||
scope: &Scope::default(),
|
||||
scope: &scope.clone(),
|
||||
rank,
|
||||
constraint,
|
||||
};
|
||||
|
||||
let mut stack = vec![initial];
|
||||
|
||||
let mut state = State {
|
||||
scope,
|
||||
mark: Mark::NONE.next(),
|
||||
};
|
||||
|
||||
while let Some(work_item) = stack.pop() {
|
||||
let (scope, rank, constraint) = match work_item {
|
||||
Work::Constraint {
|
||||
@ -1392,6 +1400,86 @@ fn solve(
|
||||
}
|
||||
}
|
||||
}
|
||||
ImportParams(opt_provided, module_id, region) => {
|
||||
match (module_params_vars.get(module_id), opt_provided) {
|
||||
(Some(expected), Some(provided)) => {
|
||||
let actual = either_type_index_to_var(
|
||||
env,
|
||||
rank,
|
||||
problems,
|
||||
abilities_store,
|
||||
obligation_cache,
|
||||
&mut can_types,
|
||||
aliases,
|
||||
*provided,
|
||||
);
|
||||
|
||||
match unify(
|
||||
&mut env.uenv(),
|
||||
actual,
|
||||
*expected,
|
||||
UnificationMode::EQ,
|
||||
Polarity::OF_VALUE,
|
||||
) {
|
||||
Success {
|
||||
vars,
|
||||
must_implement_ability,
|
||||
lambda_sets_to_specialize,
|
||||
extra_metadata: _,
|
||||
} => {
|
||||
env.introduce(rank, &vars);
|
||||
|
||||
problems.extend(obligation_cache.check_obligations(
|
||||
env.subs,
|
||||
abilities_store,
|
||||
must_implement_ability,
|
||||
AbilityImplError::DoesNotImplement,
|
||||
));
|
||||
compact_lambdas_and_check_obligations(
|
||||
env,
|
||||
problems,
|
||||
abilities_store,
|
||||
obligation_cache,
|
||||
awaiting_specializations,
|
||||
lambda_sets_to_specialize,
|
||||
);
|
||||
|
||||
state
|
||||
}
|
||||
|
||||
Failure(vars, actual_type, expected_type, _) => {
|
||||
env.introduce(rank, &vars);
|
||||
|
||||
problems.push(TypeError::ModuleParamsMismatch(
|
||||
*region,
|
||||
*module_id,
|
||||
actual_type,
|
||||
expected_type,
|
||||
));
|
||||
|
||||
state
|
||||
}
|
||||
}
|
||||
}
|
||||
(Some(expected), None) => {
|
||||
let expected_type = env.uenv().var_to_error_type(*expected, Polarity::Neg);
|
||||
|
||||
problems.push(TypeError::MissingModuleParams(
|
||||
*region,
|
||||
*module_id,
|
||||
expected_type,
|
||||
));
|
||||
|
||||
state
|
||||
}
|
||||
(None, Some(_)) => {
|
||||
problems.push(TypeError::UnexpectedModuleParams(*region, *module_id));
|
||||
|
||||
state
|
||||
}
|
||||
(None, None) => state,
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -2,13 +2,43 @@ use roc_module::symbol::Symbol;
|
||||
use roc_types::subs::Variable;
|
||||
|
||||
/// The scope of the solver, as symbols are introduced.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Scope {
|
||||
symbols: Vec<Symbol>,
|
||||
variables: Vec<Variable>,
|
||||
}
|
||||
|
||||
impl Scope {
|
||||
pub fn new(params_pattern: Option<roc_can::pattern::Pattern>) -> Self {
|
||||
match params_pattern {
|
||||
Some(params_pattern) => match params_pattern {
|
||||
roc_can::pattern::Pattern::RecordDestructure {
|
||||
whole_var: _,
|
||||
ext_var: _,
|
||||
destructs,
|
||||
} => {
|
||||
let mut symbols = Vec::with_capacity(destructs.len());
|
||||
let mut variables = Vec::with_capacity(destructs.len());
|
||||
|
||||
for destruct in destructs {
|
||||
symbols.push(destruct.value.symbol);
|
||||
variables.push(destruct.value.var);
|
||||
}
|
||||
|
||||
Self { symbols, variables }
|
||||
}
|
||||
_ => unreachable!(
|
||||
"other pattern types should have parsed: {:?}",
|
||||
params_pattern
|
||||
),
|
||||
},
|
||||
None => Self {
|
||||
symbols: Vec::default(),
|
||||
variables: Vec::default(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn vars_by_symbol(&self) -> impl Iterator<Item = (Symbol, Variable)> + '_ {
|
||||
let it1 = self.symbols.iter().copied();
|
||||
let it2 = self.variables.iter().copied();
|
||||
|
@ -2,7 +2,10 @@
|
||||
use std::{path::PathBuf, str::Utf8Error};
|
||||
|
||||
use roc_can::expected::{Expected, PExpected};
|
||||
use roc_module::{ident::Lowercase, symbol::Symbol};
|
||||
use roc_module::{
|
||||
ident::Lowercase,
|
||||
symbol::{ModuleId, Symbol},
|
||||
};
|
||||
use roc_problem::{can::CycleEntry, Severity};
|
||||
use roc_region::all::Region;
|
||||
|
||||
@ -33,6 +36,9 @@ pub enum TypeError {
|
||||
},
|
||||
IngestedFileBadUtf8(Box<PathBuf>, Utf8Error),
|
||||
IngestedFileUnsupportedType(Box<PathBuf>, ErrorType),
|
||||
UnexpectedModuleParams(Region, ModuleId),
|
||||
MissingModuleParams(Region, ModuleId, ErrorType),
|
||||
ModuleParamsMismatch(Region, ModuleId, ErrorType, ErrorType),
|
||||
}
|
||||
|
||||
impl TypeError {
|
||||
@ -52,6 +58,9 @@ impl TypeError {
|
||||
TypeError::Exhaustive(exhtv) => exhtv.severity(),
|
||||
TypeError::StructuralSpecialization { .. } => RuntimeError,
|
||||
TypeError::WrongSpecialization { .. } => RuntimeError,
|
||||
TypeError::UnexpectedModuleParams(..) => Warning,
|
||||
TypeError::MissingModuleParams(..) => RuntimeError,
|
||||
TypeError::ModuleParamsMismatch(..) => RuntimeError,
|
||||
TypeError::IngestedFileBadUtf8(..) => Fatal,
|
||||
TypeError::IngestedFileUnsupportedType(..) => Fatal,
|
||||
}
|
||||
@ -66,7 +75,10 @@ impl TypeError {
|
||||
| TypeError::BadExprMissingAbility(region, ..)
|
||||
| TypeError::StructuralSpecialization { region, .. }
|
||||
| TypeError::WrongSpecialization { region, .. }
|
||||
| TypeError::BadPatternMissingAbility(region, ..) => Some(*region),
|
||||
| TypeError::BadPatternMissingAbility(region, ..)
|
||||
| TypeError::UnexpectedModuleParams(region, ..)
|
||||
| TypeError::MissingModuleParams(region, ..)
|
||||
| TypeError::ModuleParamsMismatch(region, ..) => Some(*region),
|
||||
TypeError::UnfulfilledAbility(ab, ..) => ab.region(),
|
||||
TypeError::Exhaustive(e) => Some(e.region()),
|
||||
TypeError::CircularDef(c) => c.first().map(|ce| ce.symbol_region),
|
||||
|
@ -405,7 +405,7 @@ fn check_derived_typechecks_and_golden(
|
||||
let mut def_types = Default::default();
|
||||
let mut rigid_vars = Default::default();
|
||||
let mut flex_vars = Default::default();
|
||||
let (import_variables, abilities_store) = add_imports(
|
||||
let (import_variables, imported_param_vars, abilities_store) = add_imports(
|
||||
test_module,
|
||||
&mut constraints,
|
||||
&mut test_subs,
|
||||
@ -438,6 +438,8 @@ fn check_derived_typechecks_and_golden(
|
||||
pending_derives: Default::default(),
|
||||
exposed_by_module: &exposed_for_module.exposed_by_module,
|
||||
derived_module: Default::default(),
|
||||
params_pattern: None,
|
||||
module_params_vars: imported_param_vars,
|
||||
|
||||
#[cfg(debug_assertions)]
|
||||
checkmate: None,
|
||||
|
@ -2,93 +2,93 @@ procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
ret Bool.23;
|
||||
|
||||
procedure List.107 (List.536, List.537, List.538):
|
||||
let List.640 : U64 = 0i64;
|
||||
let List.641 : U64 = CallByName List.6 List.536;
|
||||
let List.639 : [C U64, C U64] = CallByName List.80 List.536 List.537 List.538 List.640 List.641;
|
||||
ret List.639;
|
||||
procedure List.110 (List.539, List.540, List.541):
|
||||
let List.643 : U64 = 0i64;
|
||||
let List.644 : U64 = CallByName List.6 List.539;
|
||||
let List.642 : [C U64, C U64] = CallByName List.80 List.539 List.540 List.541 List.643 List.644;
|
||||
ret List.642;
|
||||
|
||||
procedure List.26 (List.204, List.205, List.206):
|
||||
let List.633 : [C U64, C U64] = CallByName List.107 List.204 List.205 List.206;
|
||||
let List.636 : U8 = 1i64;
|
||||
let List.637 : U8 = GetTagId List.633;
|
||||
let List.638 : Int1 = lowlevel Eq List.636 List.637;
|
||||
if List.638 then
|
||||
let List.207 : U64 = UnionAtIndex (Id 1) (Index 0) List.633;
|
||||
ret List.207;
|
||||
procedure List.26 (List.207, List.208, List.209):
|
||||
let List.636 : [C U64, C U64] = CallByName List.110 List.207 List.208 List.209;
|
||||
let List.639 : U8 = 1i64;
|
||||
let List.640 : U8 = GetTagId List.636;
|
||||
let List.641 : Int1 = lowlevel Eq List.639 List.640;
|
||||
if List.641 then
|
||||
let List.210 : U64 = UnionAtIndex (Id 1) (Index 0) List.636;
|
||||
ret List.210;
|
||||
else
|
||||
let List.208 : U64 = UnionAtIndex (Id 0) (Index 0) List.633;
|
||||
ret List.208;
|
||||
let List.211 : U64 = UnionAtIndex (Id 0) (Index 0) List.636;
|
||||
ret List.211;
|
||||
|
||||
procedure List.38 (List.392, List.393):
|
||||
let List.632 : U64 = CallByName List.6 List.392;
|
||||
let List.394 : U64 = CallByName Num.77 List.632 List.393;
|
||||
let List.622 : List U8 = CallByName List.43 List.392 List.394;
|
||||
ret List.622;
|
||||
|
||||
procedure List.43 (List.390, List.391):
|
||||
let List.630 : U64 = CallByName List.6 List.390;
|
||||
let List.629 : U64 = CallByName Num.77 List.630 List.391;
|
||||
let List.624 : {U64, U64} = Struct {List.391, List.629};
|
||||
let List.623 : List U8 = CallByName List.49 List.390 List.624;
|
||||
ret List.623;
|
||||
|
||||
procedure List.49 (List.468, List.469):
|
||||
let List.626 : U64 = StructAtIndex 1 List.469;
|
||||
let List.627 : U64 = StructAtIndex 0 List.469;
|
||||
let List.625 : List U8 = CallByName List.72 List.468 List.626 List.627;
|
||||
procedure List.38 (List.395, List.396):
|
||||
let List.635 : U64 = CallByName List.6 List.395;
|
||||
let List.397 : U64 = CallByName Num.77 List.635 List.396;
|
||||
let List.625 : List U8 = CallByName List.43 List.395 List.397;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.631 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.631;
|
||||
procedure List.43 (List.393, List.394):
|
||||
let List.633 : U64 = CallByName List.6 List.393;
|
||||
let List.632 : U64 = CallByName Num.77 List.633 List.394;
|
||||
let List.627 : {U64, U64} = Struct {List.394, List.632};
|
||||
let List.626 : List U8 = CallByName List.49 List.393 List.627;
|
||||
ret List.626;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.654 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.654;
|
||||
|
||||
procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.628 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
|
||||
procedure List.49 (List.471, List.472):
|
||||
let List.629 : U64 = StructAtIndex 1 List.472;
|
||||
let List.630 : U64 = StructAtIndex 0 List.472;
|
||||
let List.628 : List U8 = CallByName List.72 List.471 List.629 List.630;
|
||||
ret List.628;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.634 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.634;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.657 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.657;
|
||||
|
||||
procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.631 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.631;
|
||||
|
||||
procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.642 List.539 List.540 List.541 List.542 List.543:
|
||||
let List.644 : Int1 = CallByName Num.22 List.542 List.543;
|
||||
if List.644 then
|
||||
let List.653 : U8 = CallByName List.66 List.539 List.542;
|
||||
let List.645 : [C U64, C U64] = CallByName Test.4 List.540 List.653;
|
||||
let List.650 : U8 = 1i64;
|
||||
let List.651 : U8 = GetTagId List.645;
|
||||
let List.652 : Int1 = lowlevel Eq List.650 List.651;
|
||||
if List.652 then
|
||||
let List.544 : U64 = UnionAtIndex (Id 1) (Index 0) List.645;
|
||||
let List.648 : U64 = 1i64;
|
||||
let List.647 : U64 = CallByName Num.51 List.542 List.648;
|
||||
jump List.642 List.539 List.544 List.541 List.647 List.543;
|
||||
joinpoint List.645 List.542 List.543 List.544 List.545 List.546:
|
||||
let List.647 : Int1 = CallByName Num.22 List.545 List.546;
|
||||
if List.647 then
|
||||
let List.656 : U8 = CallByName List.66 List.542 List.545;
|
||||
let List.648 : [C U64, C U64] = CallByName Test.4 List.543 List.656;
|
||||
let List.653 : U8 = 1i64;
|
||||
let List.654 : U8 = GetTagId List.648;
|
||||
let List.655 : Int1 = lowlevel Eq List.653 List.654;
|
||||
if List.655 then
|
||||
let List.547 : U64 = UnionAtIndex (Id 1) (Index 0) List.648;
|
||||
let List.651 : U64 = 1i64;
|
||||
let List.650 : U64 = CallByName Num.51 List.545 List.651;
|
||||
jump List.645 List.542 List.547 List.544 List.650 List.546;
|
||||
else
|
||||
dec List.539;
|
||||
let List.545 : U64 = UnionAtIndex (Id 0) (Index 0) List.645;
|
||||
let List.649 : [C U64, C U64] = TagId(0) List.545;
|
||||
ret List.649;
|
||||
dec List.542;
|
||||
let List.548 : U64 = UnionAtIndex (Id 0) (Index 0) List.648;
|
||||
let List.652 : [C U64, C U64] = TagId(0) List.548;
|
||||
ret List.652;
|
||||
else
|
||||
dec List.539;
|
||||
let List.643 : [C U64, C U64] = TagId(1) List.540;
|
||||
ret List.643;
|
||||
dec List.542;
|
||||
let List.646 : [C U64, C U64] = TagId(1) List.543;
|
||||
ret List.646;
|
||||
in
|
||||
inc #Derived_gen.0;
|
||||
jump List.642 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
jump List.645 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.77 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.13 : U64 = 0i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.4 (Test.27):
|
||||
let Test.39 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = TagId(0) ;
|
||||
|
@ -1,59 +1,59 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.163;
|
||||
let List.625 : List {} = CallByName List.92 List.163 List.164 List.165 List.626 List.627;
|
||||
ret List.625;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.629 : U64 = 0i64;
|
||||
let List.630 : U64 = CallByName List.6 List.166;
|
||||
let List.628 : List {} = CallByName List.95 List.166 List.167 List.168 List.629 List.630;
|
||||
ret List.628;
|
||||
|
||||
procedure List.275 (List.276, List.277, List.273):
|
||||
let List.639 : {} = CallByName Test.2 List.277;
|
||||
let List.638 : List {} = CallByName List.71 List.276 List.639;
|
||||
ret List.638;
|
||||
|
||||
procedure List.5 (List.272, List.273):
|
||||
let List.274 : U64 = CallByName List.6 List.272;
|
||||
let List.623 : List {} = CallByName List.68 List.274;
|
||||
let List.622 : List {} = CallByName List.18 List.272 List.623 List.273;
|
||||
ret List.622;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.635 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.641 : List {} = lowlevel ListWithCapacity #Attr.2;
|
||||
procedure List.278 (List.279, List.280, List.276):
|
||||
let List.642 : {} = CallByName Test.2 List.280;
|
||||
let List.641 : List {} = CallByName List.71 List.279 List.642;
|
||||
ret List.641;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.640 : List {} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.640;
|
||||
procedure List.5 (List.275, List.276):
|
||||
let List.277 : U64 = CallByName List.6 List.275;
|
||||
let List.626 : List {} = CallByName List.68 List.277;
|
||||
let List.625 : List {} = CallByName List.18 List.275 List.626 List.276;
|
||||
ret List.625;
|
||||
|
||||
procedure List.92 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
|
||||
joinpoint List.628 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.630 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.630 then
|
||||
let List.634 : [] = CallByName List.66 List.166 List.169;
|
||||
let List.171 : List {} = CallByName List.275 List.167 List.634 List.168;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.169 List.633;
|
||||
jump List.628 List.166 List.171 List.168 List.632 List.170;
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.639 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.639;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.638 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.644 : List {} = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.644;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.643 : List {} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.643;
|
||||
|
||||
procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.631 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.633 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.633 then
|
||||
let List.637 : [] = CallByName List.66 List.169 List.172;
|
||||
let List.174 : List {} = CallByName List.278 List.170 List.637 List.171;
|
||||
let List.636 : U64 = 1i64;
|
||||
let List.635 : U64 = CallByName Num.51 List.172 List.636;
|
||||
jump List.631 List.169 List.174 List.171 List.635 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.3;
|
||||
jump List.628 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
|
||||
inc #Derived_gen.0;
|
||||
jump List.631 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
let Test.7 : {} = Struct {};
|
||||
|
@ -1,59 +1,59 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.163;
|
||||
let List.625 : List [] = CallByName List.92 List.163 List.164 List.165 List.626 List.627;
|
||||
ret List.625;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.629 : U64 = 0i64;
|
||||
let List.630 : U64 = CallByName List.6 List.166;
|
||||
let List.628 : List [] = CallByName List.95 List.166 List.167 List.168 List.629 List.630;
|
||||
ret List.628;
|
||||
|
||||
procedure List.275 (List.276, List.277, List.273):
|
||||
let List.639 : [] = CallByName Test.2 List.277;
|
||||
let List.638 : List [] = CallByName List.71 List.276 List.639;
|
||||
ret List.638;
|
||||
|
||||
procedure List.5 (List.272, List.273):
|
||||
let List.274 : U64 = CallByName List.6 List.272;
|
||||
let List.623 : List [] = CallByName List.68 List.274;
|
||||
let List.622 : List [] = CallByName List.18 List.272 List.623 List.273;
|
||||
ret List.622;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.635 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.641 : List [] = lowlevel ListWithCapacity #Attr.2;
|
||||
procedure List.278 (List.279, List.280, List.276):
|
||||
let List.642 : [] = CallByName Test.2 List.280;
|
||||
let List.641 : List [] = CallByName List.71 List.279 List.642;
|
||||
ret List.641;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.640 : List [] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.640;
|
||||
procedure List.5 (List.275, List.276):
|
||||
let List.277 : U64 = CallByName List.6 List.275;
|
||||
let List.626 : List [] = CallByName List.68 List.277;
|
||||
let List.625 : List [] = CallByName List.18 List.275 List.626 List.276;
|
||||
ret List.625;
|
||||
|
||||
procedure List.92 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
|
||||
joinpoint List.628 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.630 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.630 then
|
||||
let List.634 : [] = CallByName List.66 List.166 List.169;
|
||||
let List.171 : List [] = CallByName List.275 List.167 List.634 List.168;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.169 List.633;
|
||||
jump List.628 List.166 List.171 List.168 List.632 List.170;
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.639 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.639;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.638 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.644 : List [] = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.644;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.643 : List [] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.643;
|
||||
|
||||
procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.631 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.633 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.633 then
|
||||
let List.637 : [] = CallByName List.66 List.169 List.172;
|
||||
let List.174 : List [] = CallByName List.278 List.170 List.637 List.171;
|
||||
let List.636 : U64 = 1i64;
|
||||
let List.635 : U64 = CallByName Num.51 List.172 List.636;
|
||||
jump List.631 List.169 List.174 List.171 List.635 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.3;
|
||||
jump List.628 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
|
||||
inc #Derived_gen.0;
|
||||
jump List.631 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
let Test.7 : {} = Struct {};
|
||||
|
@ -1,40 +1,40 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : [<r>C {}, C *self {{}, []}] = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : [<r>C {}, C *self {{}, []}] = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : [] = CallByName List.66 List.166 List.169;
|
||||
let List.171 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.167 List.631 List.168;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : [] = CallByName List.66 List.169 List.172;
|
||||
let List.174 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.170 List.634 List.171;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.11;
|
||||
jump List.625 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
|
||||
inc #Derived_gen.13;
|
||||
jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.10 (Test.69, #Attr.12):
|
||||
let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
|
@ -2,112 +2,112 @@ procedure Bool.1 ():
|
||||
let Bool.24 : Int1 = false;
|
||||
ret Bool.24;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.642 : U64 = 0i64;
|
||||
let List.643 : U64 = CallByName List.6 List.163;
|
||||
let List.641 : List Str = CallByName List.92 List.163 List.164 List.165 List.642 List.643;
|
||||
ret List.641;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.645 : U64 = 0i64;
|
||||
let List.646 : U64 = CallByName List.6 List.166;
|
||||
let List.644 : List Str = CallByName List.95 List.166 List.167 List.168 List.645 List.646;
|
||||
ret List.644;
|
||||
|
||||
procedure List.2 (List.111, List.112):
|
||||
let List.636 : U64 = CallByName List.6 List.111;
|
||||
let List.632 : Int1 = CallByName Num.22 List.112 List.636;
|
||||
if List.632 then
|
||||
let List.634 : Str = CallByName List.66 List.111 List.112;
|
||||
inc List.634;
|
||||
let List.633 : [C {}, C Str] = TagId(1) List.634;
|
||||
ret List.633;
|
||||
procedure List.2 (List.114, List.115):
|
||||
let List.639 : U64 = CallByName List.6 List.114;
|
||||
let List.635 : Int1 = CallByName Num.22 List.115 List.639;
|
||||
if List.635 then
|
||||
let List.637 : Str = CallByName List.66 List.114 List.115;
|
||||
inc List.637;
|
||||
let List.636 : [C {}, C Str] = TagId(1) List.637;
|
||||
ret List.636;
|
||||
else
|
||||
let List.631 : {} = Struct {};
|
||||
let List.630 : [C {}, C Str] = TagId(0) List.631;
|
||||
ret List.630;
|
||||
let List.634 : {} = Struct {};
|
||||
let List.633 : [C {}, C Str] = TagId(0) List.634;
|
||||
ret List.633;
|
||||
|
||||
procedure List.275 (List.276, List.277, List.273):
|
||||
let List.655 : Str = CallByName Test.10 List.277;
|
||||
let List.654 : List Str = CallByName List.71 List.276 List.655;
|
||||
ret List.654;
|
||||
|
||||
procedure List.5 (List.272, List.273):
|
||||
let List.274 : U64 = CallByName List.6 List.272;
|
||||
let List.639 : List Str = CallByName List.68 List.274;
|
||||
let List.638 : List Str = CallByName List.18 List.272 List.639 List.273;
|
||||
ret List.638;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.637 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.637;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.652 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.652;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.651 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.651;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.657 : List Str = lowlevel ListWithCapacity #Attr.2;
|
||||
procedure List.278 (List.279, List.280, List.276):
|
||||
let List.658 : Str = CallByName Test.10 List.280;
|
||||
let List.657 : List Str = CallByName List.71 List.279 List.658;
|
||||
ret List.657;
|
||||
|
||||
procedure List.5 (List.275, List.276):
|
||||
let List.277 : U64 = CallByName List.6 List.275;
|
||||
let List.642 : List Str = CallByName List.68 List.277;
|
||||
let List.641 : List Str = CallByName List.18 List.275 List.642 List.276;
|
||||
ret List.641;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.640 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.640;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.655 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.655;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.638 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.654 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.654;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.660 : List Str = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.660;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.656 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.656;
|
||||
let List.659 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.659;
|
||||
|
||||
procedure List.9 (List.383):
|
||||
let List.629 : U64 = 0i64;
|
||||
let List.622 : [C {}, C Str] = CallByName List.2 List.383 List.629;
|
||||
let List.626 : U8 = 1i64;
|
||||
let List.627 : U8 = GetTagId List.622;
|
||||
let List.628 : Int1 = lowlevel Eq List.626 List.627;
|
||||
if List.628 then
|
||||
let List.384 : Str = UnionAtIndex (Id 1) (Index 0) List.622;
|
||||
let List.623 : [C {}, C Str] = TagId(1) List.384;
|
||||
ret List.623;
|
||||
procedure List.9 (List.386):
|
||||
let List.632 : U64 = 0i64;
|
||||
let List.625 : [C {}, C Str] = CallByName List.2 List.386 List.632;
|
||||
let List.629 : U8 = 1i64;
|
||||
let List.630 : U8 = GetTagId List.625;
|
||||
let List.631 : Int1 = lowlevel Eq List.629 List.630;
|
||||
if List.631 then
|
||||
let List.387 : Str = UnionAtIndex (Id 1) (Index 0) List.625;
|
||||
let List.626 : [C {}, C Str] = TagId(1) List.387;
|
||||
ret List.626;
|
||||
else
|
||||
dec List.622;
|
||||
let List.625 : {} = Struct {};
|
||||
let List.624 : [C {}, C Str] = TagId(0) List.625;
|
||||
ret List.624;
|
||||
dec List.625;
|
||||
let List.628 : {} = Struct {};
|
||||
let List.627 : [C {}, C Str] = TagId(0) List.628;
|
||||
ret List.627;
|
||||
|
||||
procedure List.92 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
|
||||
joinpoint List.644 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.646 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.646 then
|
||||
let List.650 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = CallByName List.66 List.166 List.169;
|
||||
inc List.650;
|
||||
let List.171 : List Str = CallByName List.275 List.167 List.650 List.168;
|
||||
let List.649 : U64 = 1i64;
|
||||
let List.648 : U64 = CallByName Num.51 List.169 List.649;
|
||||
jump List.644 List.166 List.171 List.168 List.648 List.170;
|
||||
procedure List.95 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
|
||||
joinpoint List.647 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.649 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.649 then
|
||||
let List.653 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = CallByName List.66 List.169 List.172;
|
||||
inc List.653;
|
||||
let List.174 : List Str = CallByName List.278 List.170 List.653 List.171;
|
||||
let List.652 : U64 = 1i64;
|
||||
let List.651 : U64 = CallByName Num.51 List.172 List.652;
|
||||
jump List.647 List.169 List.174 List.171 List.651 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.4;
|
||||
jump List.644 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
|
||||
jump List.647 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Result.5 (Result.12, Result.13):
|
||||
let Result.52 : U8 = 1i64;
|
||||
let Result.53 : U8 = GetTagId Result.12;
|
||||
let Result.54 : Int1 = lowlevel Eq Result.52 Result.53;
|
||||
if Result.54 then
|
||||
dec Result.13;
|
||||
let Result.14 : Str = UnionAtIndex (Id 1) (Index 0) Result.12;
|
||||
ret Result.14;
|
||||
procedure Result.5 (Result.13, Result.14):
|
||||
let Result.57 : U8 = 1i64;
|
||||
let Result.58 : U8 = GetTagId Result.13;
|
||||
let Result.59 : Int1 = lowlevel Eq Result.57 Result.58;
|
||||
if Result.59 then
|
||||
dec Result.14;
|
||||
let Result.15 : Str = UnionAtIndex (Id 1) (Index 0) Result.13;
|
||||
ret Result.15;
|
||||
else
|
||||
dec Result.12;
|
||||
ret Result.13;
|
||||
dec Result.13;
|
||||
ret Result.14;
|
||||
|
||||
procedure Test.10 (Test.11):
|
||||
let Test.12 : Str = CallByName Test.2 Test.11;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.280 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.6 : I128 = 18446744073709551616i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : U128 = 170141183460469231731687303715884105728u128;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : U64 = 9999999999999999999i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.622;
|
||||
let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.625;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.2 : I64 = 41i64;
|
||||
|
@ -2,47 +2,47 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : Int1 = CallByName List.66 List.166 List.169;
|
||||
let List.171 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.167 List.631 List.168;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : Int1 = CallByName List.66 List.169 List.172;
|
||||
let List.174 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.170 List.634 List.171;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.5;
|
||||
jump List.625 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
|
||||
jump List.628 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.234 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.234;
|
||||
let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.238;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
ret Test.5;
|
||||
|
@ -2,50 +2,50 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.323 : Str = "\"";
|
||||
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
|
||||
dec Inspect.323;
|
||||
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
|
||||
let Inspect.319 : Str = "\"";
|
||||
let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
|
||||
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
|
||||
dec Inspect.319;
|
||||
let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
|
||||
let Inspect.315 : Str = "\"";
|
||||
let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
|
||||
dec Inspect.315;
|
||||
ret Inspect.313;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.309;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
|
||||
dec Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
ret Inspect.317;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.313;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
|
||||
dec Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.321;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.1 ():
|
||||
let Test.4 : Str = "";
|
||||
|
@ -1,47 +1,47 @@
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.323 : Str = "\"";
|
||||
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
|
||||
dec Inspect.323;
|
||||
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
|
||||
let Inspect.319 : Str = "\"";
|
||||
let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
|
||||
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
|
||||
dec Inspect.319;
|
||||
let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
|
||||
let Inspect.315 : Str = "\"";
|
||||
let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
|
||||
dec Inspect.315;
|
||||
ret Inspect.313;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.309;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
|
||||
dec Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
ret Inspect.317;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.313;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
|
||||
dec Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.321;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : Str = "";
|
||||
|
56
crates/compiler/test_mono/generated/dict.txt
generated
56
crates/compiler/test_mono/generated/dict.txt
generated
@ -1,37 +1,37 @@
|
||||
procedure Dict.1 (Dict.723):
|
||||
let Dict.732 : List {U32, U32} = Array [];
|
||||
let Dict.733 : List {[], []} = Array [];
|
||||
let Dict.734 : U64 = 0i64;
|
||||
let Dict.44 : Float32 = CallByName Dict.44;
|
||||
let Dict.45 : U8 = CallByName Dict.45;
|
||||
let Dict.731 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.732, Dict.733, Dict.734, Dict.44, Dict.45};
|
||||
ret Dict.731;
|
||||
|
||||
procedure Dict.4 (Dict.729):
|
||||
let Dict.156 : List {[], []} = StructAtIndex 1 Dict.729;
|
||||
let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.729;
|
||||
dec #Derived_gen.0;
|
||||
let Dict.730 : U64 = CallByName List.6 Dict.156;
|
||||
dec Dict.156;
|
||||
ret Dict.730;
|
||||
|
||||
procedure Dict.44 ():
|
||||
let Dict.738 : Float32 = 0.8f64;
|
||||
procedure Dict.1 (Dict.730):
|
||||
let Dict.739 : List {U32, U32} = Array [];
|
||||
let Dict.740 : List {[], []} = Array [];
|
||||
let Dict.741 : U64 = 0i64;
|
||||
let Dict.51 : Float32 = CallByName Dict.51;
|
||||
let Dict.52 : U8 = CallByName Dict.52;
|
||||
let Dict.738 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.739, Dict.740, Dict.741, Dict.51, Dict.52};
|
||||
ret Dict.738;
|
||||
|
||||
procedure Dict.45 ():
|
||||
let Dict.736 : U8 = 64i64;
|
||||
let Dict.737 : U8 = 3i64;
|
||||
let Dict.735 : U8 = CallByName Num.75 Dict.736 Dict.737;
|
||||
ret Dict.735;
|
||||
procedure Dict.4 (Dict.736):
|
||||
let Dict.163 : List {[], []} = StructAtIndex 1 Dict.736;
|
||||
let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.736;
|
||||
dec #Derived_gen.0;
|
||||
let Dict.737 : U64 = CallByName List.6 Dict.163;
|
||||
dec Dict.163;
|
||||
ret Dict.737;
|
||||
|
||||
procedure Dict.51 ():
|
||||
let Dict.745 : Float32 = 0.8f64;
|
||||
ret Dict.745;
|
||||
|
||||
procedure Dict.52 ():
|
||||
let Dict.743 : U8 = 64i64;
|
||||
let Dict.744 : U8 = 3i64;
|
||||
let Dict.742 : U8 = CallByName Num.75 Dict.743 Dict.744;
|
||||
ret Dict.742;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.622;
|
||||
let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.625;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : {} = Struct {};
|
||||
|
@ -2,29 +2,29 @@ procedure Bool.1 ():
|
||||
let Bool.23 : Int1 = false;
|
||||
ret Bool.23;
|
||||
|
||||
procedure List.2 (List.111, List.112):
|
||||
let List.628 : U64 = CallByName List.6 List.111;
|
||||
let List.624 : Int1 = CallByName Num.22 List.112 List.628;
|
||||
if List.624 then
|
||||
let List.626 : {} = CallByName List.66 List.111 List.112;
|
||||
let List.625 : [C {}, C {}] = TagId(1) List.626;
|
||||
ret List.625;
|
||||
procedure List.2 (List.114, List.115):
|
||||
let List.631 : U64 = CallByName List.6 List.114;
|
||||
let List.627 : Int1 = CallByName Num.22 List.115 List.631;
|
||||
if List.627 then
|
||||
let List.629 : {} = CallByName List.66 List.114 List.115;
|
||||
let List.628 : [C {}, C {}] = TagId(1) List.629;
|
||||
ret List.628;
|
||||
else
|
||||
let List.623 : {} = Struct {};
|
||||
let List.622 : [C {}, C {}] = TagId(0) List.623;
|
||||
ret List.622;
|
||||
let List.626 : {} = Struct {};
|
||||
let List.625 : [C {}, C {}] = TagId(0) List.626;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.629 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.629;
|
||||
let List.632 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.632;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.627 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
let List.630 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.630;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.2 (Test.5):
|
||||
let Test.17 : Str = "bar";
|
||||
|
18
crates/compiler/test_mono/generated/encode.txt
generated
18
crates/compiler/test_mono/generated/encode.txt
generated
@ -1,16 +1,16 @@
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.625 : U64 = 1i64;
|
||||
let List.623 : List U8 = CallByName List.70 List.127 List.625;
|
||||
let List.622 : List U8 = CallByName List.71 List.623 List.128;
|
||||
ret List.622;
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.628 : U64 = 1i64;
|
||||
let List.626 : List U8 = CallByName List.70 List.130 List.628;
|
||||
let List.625 : List U8 = CallByName List.71 List.626 List.131;
|
||||
ret List.625;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.626 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.626;
|
||||
let List.629 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.629;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.624 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.624;
|
||||
let List.627 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure Test.23 (Test.24, Test.35, Test.22):
|
||||
let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;
|
||||
|
@ -7,7 +7,7 @@ procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
|
||||
let #Derived_gen.8 : Str = CallByName #Derived.5 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Test.21 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Test.22 #Derived_gen.5;
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.4 #Derived.4;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
@ -18,263 +18,263 @@ procedure #Derived.5 (#Derived.6):
|
||||
|
||||
procedure #Derived.7 (#Derived.8, #Derived.9, #Derived.6):
|
||||
let #Derived_gen.17 : Str = "b";
|
||||
let #Derived_gen.18 : Str = CallByName Test.19 #Derived.6;
|
||||
let #Derived_gen.18 : Str = CallByName Test.20 #Derived.6;
|
||||
let #Derived_gen.16 : {Str, Str} = Struct {#Derived_gen.17, #Derived_gen.18};
|
||||
let #Derived_gen.15 : List {Str, Str} = Array [#Derived_gen.16];
|
||||
let #Derived_gen.14 : List {Str, Str} = CallByName Test.21 #Derived_gen.15;
|
||||
let #Derived_gen.14 : List {Str, Str} = CallByName Test.22 #Derived_gen.15;
|
||||
let #Derived_gen.13 : List U8 = CallByName Encode.24 #Derived.8 #Derived_gen.14 #Derived.9;
|
||||
dec #Derived_gen.14;
|
||||
ret #Derived_gen.13;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName #Derived.2 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.113 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.113 : List U8 = CallByName #Derived.2 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.113;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.116 : List U8 = CallByName #Derived.7 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.116;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.115 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.115;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.119 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.119;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.118 : List U8 = CallByName #Derived.7 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.118;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.124 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.124;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.121 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.121;
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : Str = CallByName #Derived.0 Encode.105;
|
||||
let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
|
||||
ret Encode.108;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.126 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.126;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Encode.26 (Encode.107, Encode.108):
|
||||
let Encode.111 : List U8 = Array [];
|
||||
let Encode.112 : Str = CallByName #Derived.0 Encode.107;
|
||||
let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
|
||||
ret Encode.110;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.649 : U64 = 0i64;
|
||||
let List.650 : U64 = CallByName List.6 List.163;
|
||||
let List.648 : List U8 = CallByName List.92 List.163 List.164 List.165 List.649 List.650;
|
||||
ret List.648;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.670 : U64 = 1i64;
|
||||
let List.669 : List U8 = CallByName List.70 List.127 List.670;
|
||||
let List.668 : List U8 = CallByName List.71 List.669 List.128;
|
||||
ret List.668;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.652 : U64 = 0i64;
|
||||
let List.653 : U64 = CallByName List.6 List.166;
|
||||
let List.651 : List U8 = CallByName List.95 List.166 List.167 List.168 List.652 List.653;
|
||||
ret List.651;
|
||||
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.673 : U64 = 1i64;
|
||||
let List.672 : List U8 = CallByName List.70 List.130 List.673;
|
||||
let List.671 : List U8 = CallByName List.71 List.672 List.131;
|
||||
ret List.671;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.647;
|
||||
let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.673 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.673;
|
||||
let List.676 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.676;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.658 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.658;
|
||||
let List.661 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.661;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.664 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.664;
|
||||
let List.667 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.667;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.662 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.662;
|
||||
let List.665 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.665;
|
||||
|
||||
procedure List.8 (#Attr.2, #Attr.3):
|
||||
let List.672 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.672;
|
||||
let List.675 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.675;
|
||||
|
||||
procedure List.92 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
|
||||
joinpoint List.651 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.653 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.653 then
|
||||
let List.657 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.657;
|
||||
let List.171 : List U8 = CallByName Test.70 List.167 List.657;
|
||||
let List.656 : U64 = 1i64;
|
||||
let List.655 : U64 = CallByName Num.51 List.169 List.656;
|
||||
jump List.651 List.166 List.171 List.168 List.655 List.170;
|
||||
procedure List.95 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : List U8 = CallByName Test.71 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.29;
|
||||
jump List.651 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
|
||||
inc #Derived_gen.26;
|
||||
jump List.628 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
|
||||
|
||||
procedure List.92 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : List U8 = CallByName Test.70 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
|
||||
joinpoint List.654 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.656 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.656 then
|
||||
let List.660 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.660;
|
||||
let List.174 : List U8 = CallByName Test.71 List.170 List.660;
|
||||
let List.659 : U64 = 1i64;
|
||||
let List.658 : U64 = CallByName Num.51 List.172 List.659;
|
||||
jump List.654 List.169 List.174 List.171 List.658 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.37;
|
||||
jump List.625 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
|
||||
inc #Derived_gen.40;
|
||||
jump List.654 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
let Num.286 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.285;
|
||||
let Num.287 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.283 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.283;
|
||||
let Num.285 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.285;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.244 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.244;
|
||||
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.248;
|
||||
|
||||
procedure Str.36 (#Attr.2):
|
||||
let Str.245 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.245;
|
||||
let Str.249 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.249;
|
||||
|
||||
procedure Str.43 (#Attr.2):
|
||||
let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.239;
|
||||
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.243;
|
||||
|
||||
procedure Str.9 (Str.67):
|
||||
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
|
||||
let Str.236 : Int1 = StructAtIndex 2 Str.68;
|
||||
if Str.236 then
|
||||
let Str.238 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
|
||||
ret Str.237;
|
||||
procedure Str.9 (Str.71):
|
||||
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
|
||||
let Str.240 : Int1 = StructAtIndex 2 Str.72;
|
||||
if Str.240 then
|
||||
let Str.242 : Str = StructAtIndex 1 Str.72;
|
||||
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
|
||||
ret Str.241;
|
||||
else
|
||||
let Str.234 : U8 = StructAtIndex 3 Str.68;
|
||||
let Str.235 : U64 = StructAtIndex 0 Str.68;
|
||||
let #Derived_gen.45 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.238 : U8 = StructAtIndex 3 Str.72;
|
||||
let Str.239 : U64 = StructAtIndex 0 Str.72;
|
||||
let #Derived_gen.45 : Str = StructAtIndex 1 Str.72;
|
||||
dec #Derived_gen.45;
|
||||
let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
|
||||
let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
|
||||
ret Str.232;
|
||||
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
|
||||
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.19 (Test.55):
|
||||
let Test.324 : Str = CallByName Encode.23 Test.55;
|
||||
ret Test.324;
|
||||
procedure Test.20 (Test.56):
|
||||
let Test.325 : Str = CallByName Encode.23 Test.56;
|
||||
ret Test.325;
|
||||
|
||||
procedure Test.2 ():
|
||||
let Test.257 : {} = Struct {};
|
||||
ret Test.257;
|
||||
procedure Test.22 (Test.67):
|
||||
let Test.261 : List {Str, Str} = CallByName Encode.23 Test.67;
|
||||
ret Test.261;
|
||||
|
||||
procedure Test.21 (Test.66):
|
||||
let Test.260 : List {Str, Str} = CallByName Encode.23 Test.66;
|
||||
ret Test.260;
|
||||
procedure Test.22 (Test.67):
|
||||
let Test.293 : List {Str, Str} = CallByName Encode.23 Test.67;
|
||||
ret Test.293;
|
||||
|
||||
procedure Test.21 (Test.66):
|
||||
let Test.292 : List {Str, Str} = CallByName Encode.23 Test.66;
|
||||
ret Test.292;
|
||||
procedure Test.3 ():
|
||||
let Test.258 : {} = Struct {};
|
||||
ret Test.258;
|
||||
|
||||
procedure Test.3 (Test.48, Test.49, Test.50):
|
||||
let Test.321 : U8 = CallByName Num.127 Test.49;
|
||||
let Test.318 : List U8 = CallByName List.4 Test.48 Test.321;
|
||||
let Test.320 : Str = CallByName Num.96 Test.50;
|
||||
let Test.319 : List U8 = CallByName Str.12 Test.320;
|
||||
let Test.316 : List U8 = CallByName List.8 Test.318 Test.319;
|
||||
let Test.317 : U8 = 32i64;
|
||||
let Test.315 : List U8 = CallByName List.4 Test.316 Test.317;
|
||||
ret Test.315;
|
||||
procedure Test.4 (Test.49, Test.50, Test.51):
|
||||
let Test.322 : U8 = CallByName Num.127 Test.50;
|
||||
let Test.319 : List U8 = CallByName List.4 Test.49 Test.322;
|
||||
let Test.321 : Str = CallByName Num.96 Test.51;
|
||||
let Test.320 : List U8 = CallByName Str.12 Test.321;
|
||||
let Test.317 : List U8 = CallByName List.8 Test.319 Test.320;
|
||||
let Test.318 : U8 = 32i64;
|
||||
let Test.316 : List U8 = CallByName List.4 Test.317 Test.318;
|
||||
ret Test.316;
|
||||
|
||||
procedure Test.56 (Test.57, Test.274, Test.55):
|
||||
let Test.313 : I64 = 115i64;
|
||||
let Test.314 : U64 = CallByName Str.36 Test.55;
|
||||
let Test.311 : List U8 = CallByName Test.3 Test.57 Test.313 Test.314;
|
||||
let Test.312 : List U8 = CallByName Str.12 Test.55;
|
||||
let Test.309 : List U8 = CallByName List.8 Test.311 Test.312;
|
||||
let Test.310 : U8 = 32i64;
|
||||
let Test.308 : List U8 = CallByName List.4 Test.309 Test.310;
|
||||
ret Test.308;
|
||||
procedure Test.57 (Test.58, Test.275, Test.56):
|
||||
let Test.314 : I64 = 115i64;
|
||||
let Test.315 : U64 = CallByName Str.36 Test.56;
|
||||
let Test.312 : List U8 = CallByName Test.4 Test.58 Test.314 Test.315;
|
||||
let Test.313 : List U8 = CallByName Str.12 Test.56;
|
||||
let Test.310 : List U8 = CallByName List.8 Test.312 Test.313;
|
||||
let Test.311 : U8 = 32i64;
|
||||
let Test.309 : List U8 = CallByName List.4 Test.310 Test.311;
|
||||
ret Test.309;
|
||||
|
||||
procedure Test.67 (Test.68, Test.262, Test.66):
|
||||
let Test.290 : I64 = 114i64;
|
||||
let Test.291 : U64 = CallByName List.6 Test.66;
|
||||
let Test.69 : List U8 = CallByName Test.3 Test.68 Test.290 Test.291;
|
||||
let Test.265 : {} = Struct {};
|
||||
let Test.264 : List U8 = CallByName List.18 Test.66 Test.69 Test.265;
|
||||
ret Test.264;
|
||||
procedure Test.68 (Test.69, Test.263, Test.67):
|
||||
let Test.291 : I64 = 114i64;
|
||||
let Test.292 : U64 = CallByName List.6 Test.67;
|
||||
let Test.70 : List U8 = CallByName Test.4 Test.69 Test.291 Test.292;
|
||||
let Test.266 : {} = Struct {};
|
||||
let Test.265 : List U8 = CallByName List.18 Test.67 Test.70 Test.266;
|
||||
ret Test.265;
|
||||
|
||||
procedure Test.67 (Test.68, Test.262, Test.66):
|
||||
let Test.322 : I64 = 114i64;
|
||||
let Test.323 : U64 = CallByName List.6 Test.66;
|
||||
let Test.69 : List U8 = CallByName Test.3 Test.68 Test.322 Test.323;
|
||||
let Test.297 : {} = Struct {};
|
||||
let Test.296 : List U8 = CallByName List.18 Test.66 Test.69 Test.297;
|
||||
ret Test.296;
|
||||
procedure Test.68 (Test.69, Test.263, Test.67):
|
||||
let Test.323 : I64 = 114i64;
|
||||
let Test.324 : U64 = CallByName List.6 Test.67;
|
||||
let Test.70 : List U8 = CallByName Test.4 Test.69 Test.323 Test.324;
|
||||
let Test.298 : {} = Struct {};
|
||||
let Test.297 : List U8 = CallByName List.18 Test.67 Test.70 Test.298;
|
||||
ret Test.297;
|
||||
|
||||
procedure Test.70 (Test.71, Test.266):
|
||||
let Test.72 : Str = StructAtIndex 0 Test.266;
|
||||
let Test.73 : Str = StructAtIndex 1 Test.266;
|
||||
let Test.270 : Str = CallByName Test.19 Test.72;
|
||||
let Test.271 : {} = Struct {};
|
||||
let Test.268 : List U8 = CallByName Encode.24 Test.71 Test.270 Test.271;
|
||||
let Test.269 : {} = Struct {};
|
||||
let Test.267 : List U8 = CallByName Encode.24 Test.268 Test.73 Test.269;
|
||||
ret Test.267;
|
||||
procedure Test.71 (Test.72, Test.267):
|
||||
let Test.73 : Str = StructAtIndex 0 Test.267;
|
||||
let Test.74 : Str = StructAtIndex 1 Test.267;
|
||||
let Test.271 : Str = CallByName Test.20 Test.73;
|
||||
let Test.272 : {} = Struct {};
|
||||
let Test.269 : List U8 = CallByName Encode.24 Test.72 Test.271 Test.272;
|
||||
let Test.270 : {} = Struct {};
|
||||
let Test.268 : List U8 = CallByName Encode.24 Test.269 Test.74 Test.270;
|
||||
ret Test.268;
|
||||
|
||||
procedure Test.70 (Test.71, Test.266):
|
||||
let Test.72 : Str = StructAtIndex 0 Test.266;
|
||||
let Test.73 : Str = StructAtIndex 1 Test.266;
|
||||
let Test.302 : Str = CallByName Test.19 Test.72;
|
||||
let Test.303 : {} = Struct {};
|
||||
let Test.300 : List U8 = CallByName Encode.24 Test.71 Test.302 Test.303;
|
||||
let Test.301 : {} = Struct {};
|
||||
let Test.299 : List U8 = CallByName Encode.24 Test.300 Test.73 Test.301;
|
||||
ret Test.299;
|
||||
procedure Test.71 (Test.72, Test.267):
|
||||
let Test.73 : Str = StructAtIndex 0 Test.267;
|
||||
let Test.74 : Str = StructAtIndex 1 Test.267;
|
||||
let Test.303 : Str = CallByName Test.20 Test.73;
|
||||
let Test.304 : {} = Struct {};
|
||||
let Test.301 : List U8 = CallByName Encode.24 Test.72 Test.303 Test.304;
|
||||
let Test.302 : {} = Struct {};
|
||||
let Test.300 : List U8 = CallByName Encode.24 Test.301 Test.74 Test.302;
|
||||
ret Test.300;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.259 : Str = "bar";
|
||||
let Test.256 : {} = CallByName Test.2;
|
||||
let Test.254 : List U8 = CallByName Encode.26 Test.259 Test.256;
|
||||
let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
|
||||
let Test.251 : U8 = 1i64;
|
||||
let Test.252 : U8 = GetTagId Test.209;
|
||||
let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
|
||||
if Test.253 then
|
||||
let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
|
||||
ret Test.210;
|
||||
let Test.260 : Str = "bar";
|
||||
let Test.257 : {} = CallByName Test.3;
|
||||
let Test.255 : List U8 = CallByName Encode.26 Test.260 Test.257;
|
||||
let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
|
||||
let Test.252 : U8 = 1i64;
|
||||
let Test.253 : U8 = GetTagId Test.210;
|
||||
let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
|
||||
if Test.254 then
|
||||
let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
|
||||
ret Test.211;
|
||||
else
|
||||
dec Test.209;
|
||||
let Test.250 : Str = "<bad>";
|
||||
ret Test.250;
|
||||
dec Test.210;
|
||||
let Test.251 : Str = "<bad>";
|
||||
ret Test.251;
|
||||
|
@ -4,196 +4,196 @@ procedure #Derived.0 (#Derived.1):
|
||||
|
||||
procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
|
||||
let #Derived_gen.7 : Str = "a";
|
||||
let #Derived_gen.8 : Str = CallByName Test.19 #Derived.1;
|
||||
let #Derived_gen.8 : Str = CallByName Test.20 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Test.21 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Test.22 #Derived_gen.5;
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.4 #Derived.4;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName #Derived.2 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.113 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.113 : List U8 = CallByName #Derived.2 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.113;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.118 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.118;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.115 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.115;
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : Str = CallByName #Derived.0 Encode.105;
|
||||
let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
|
||||
ret Encode.108;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.120 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.120;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Encode.26 (Encode.107, Encode.108):
|
||||
let Encode.111 : List U8 = Array [];
|
||||
let Encode.112 : Str = CallByName #Derived.0 Encode.107;
|
||||
let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
|
||||
ret Encode.110;
|
||||
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : List U8 = CallByName List.70 List.127 List.644;
|
||||
let List.642 : List U8 = CallByName List.71 List.643 List.128;
|
||||
ret List.642;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.647 : U64 = 1i64;
|
||||
let List.646 : List U8 = CallByName List.70 List.130 List.647;
|
||||
let List.645 : List U8 = CallByName List.71 List.646 List.131;
|
||||
ret List.645;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.647;
|
||||
let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.641;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.636;
|
||||
let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.639;
|
||||
|
||||
procedure List.8 (#Attr.2, #Attr.3):
|
||||
let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.646;
|
||||
let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.649;
|
||||
|
||||
procedure List.92 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : List U8 = CallByName Test.70 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : List U8 = CallByName Test.71 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.13;
|
||||
jump List.625 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
|
||||
jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.241;
|
||||
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.245;
|
||||
|
||||
procedure Str.36 (#Attr.2):
|
||||
let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.242;
|
||||
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.246;
|
||||
|
||||
procedure Str.43 (#Attr.2):
|
||||
let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.239;
|
||||
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.243;
|
||||
|
||||
procedure Str.9 (Str.67):
|
||||
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
|
||||
let Str.236 : Int1 = StructAtIndex 2 Str.68;
|
||||
if Str.236 then
|
||||
let Str.238 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
|
||||
ret Str.237;
|
||||
procedure Str.9 (Str.71):
|
||||
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
|
||||
let Str.240 : Int1 = StructAtIndex 2 Str.72;
|
||||
if Str.240 then
|
||||
let Str.242 : Str = StructAtIndex 1 Str.72;
|
||||
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
|
||||
ret Str.241;
|
||||
else
|
||||
let Str.234 : U8 = StructAtIndex 3 Str.68;
|
||||
let Str.235 : U64 = StructAtIndex 0 Str.68;
|
||||
let #Derived_gen.24 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.238 : U8 = StructAtIndex 3 Str.72;
|
||||
let Str.239 : U64 = StructAtIndex 0 Str.72;
|
||||
let #Derived_gen.24 : Str = StructAtIndex 1 Str.72;
|
||||
dec #Derived_gen.24;
|
||||
let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
|
||||
let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
|
||||
ret Str.232;
|
||||
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
|
||||
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.19 (Test.55):
|
||||
let Test.291 : Str = CallByName Encode.23 Test.55;
|
||||
ret Test.291;
|
||||
procedure Test.20 (Test.56):
|
||||
let Test.292 : Str = CallByName Encode.23 Test.56;
|
||||
ret Test.292;
|
||||
|
||||
procedure Test.2 ():
|
||||
let Test.257 : {} = Struct {};
|
||||
ret Test.257;
|
||||
procedure Test.22 (Test.67):
|
||||
let Test.260 : List {Str, Str} = CallByName Encode.23 Test.67;
|
||||
ret Test.260;
|
||||
|
||||
procedure Test.21 (Test.66):
|
||||
let Test.259 : List {Str, Str} = CallByName Encode.23 Test.66;
|
||||
ret Test.259;
|
||||
procedure Test.3 ():
|
||||
let Test.258 : {} = Struct {};
|
||||
ret Test.258;
|
||||
|
||||
procedure Test.3 (Test.48, Test.49, Test.50):
|
||||
let Test.288 : U8 = CallByName Num.127 Test.49;
|
||||
let Test.285 : List U8 = CallByName List.4 Test.48 Test.288;
|
||||
let Test.287 : Str = CallByName Num.96 Test.50;
|
||||
let Test.286 : List U8 = CallByName Str.12 Test.287;
|
||||
let Test.283 : List U8 = CallByName List.8 Test.285 Test.286;
|
||||
let Test.284 : U8 = 32i64;
|
||||
let Test.282 : List U8 = CallByName List.4 Test.283 Test.284;
|
||||
ret Test.282;
|
||||
procedure Test.4 (Test.49, Test.50, Test.51):
|
||||
let Test.289 : U8 = CallByName Num.127 Test.50;
|
||||
let Test.286 : List U8 = CallByName List.4 Test.49 Test.289;
|
||||
let Test.288 : Str = CallByName Num.96 Test.51;
|
||||
let Test.287 : List U8 = CallByName Str.12 Test.288;
|
||||
let Test.284 : List U8 = CallByName List.8 Test.286 Test.287;
|
||||
let Test.285 : U8 = 32i64;
|
||||
let Test.283 : List U8 = CallByName List.4 Test.284 Test.285;
|
||||
ret Test.283;
|
||||
|
||||
procedure Test.56 (Test.57, Test.273, Test.55):
|
||||
let Test.280 : I64 = 115i64;
|
||||
let Test.281 : U64 = CallByName Str.36 Test.55;
|
||||
let Test.278 : List U8 = CallByName Test.3 Test.57 Test.280 Test.281;
|
||||
let Test.279 : List U8 = CallByName Str.12 Test.55;
|
||||
let Test.276 : List U8 = CallByName List.8 Test.278 Test.279;
|
||||
let Test.277 : U8 = 32i64;
|
||||
let Test.275 : List U8 = CallByName List.4 Test.276 Test.277;
|
||||
ret Test.275;
|
||||
procedure Test.57 (Test.58, Test.274, Test.56):
|
||||
let Test.281 : I64 = 115i64;
|
||||
let Test.282 : U64 = CallByName Str.36 Test.56;
|
||||
let Test.279 : List U8 = CallByName Test.4 Test.58 Test.281 Test.282;
|
||||
let Test.280 : List U8 = CallByName Str.12 Test.56;
|
||||
let Test.277 : List U8 = CallByName List.8 Test.279 Test.280;
|
||||
let Test.278 : U8 = 32i64;
|
||||
let Test.276 : List U8 = CallByName List.4 Test.277 Test.278;
|
||||
ret Test.276;
|
||||
|
||||
procedure Test.67 (Test.68, Test.261, Test.66):
|
||||
let Test.289 : I64 = 114i64;
|
||||
let Test.290 : U64 = CallByName List.6 Test.66;
|
||||
let Test.69 : List U8 = CallByName Test.3 Test.68 Test.289 Test.290;
|
||||
let Test.264 : {} = Struct {};
|
||||
let Test.263 : List U8 = CallByName List.18 Test.66 Test.69 Test.264;
|
||||
ret Test.263;
|
||||
procedure Test.68 (Test.69, Test.262, Test.67):
|
||||
let Test.290 : I64 = 114i64;
|
||||
let Test.291 : U64 = CallByName List.6 Test.67;
|
||||
let Test.70 : List U8 = CallByName Test.4 Test.69 Test.290 Test.291;
|
||||
let Test.265 : {} = Struct {};
|
||||
let Test.264 : List U8 = CallByName List.18 Test.67 Test.70 Test.265;
|
||||
ret Test.264;
|
||||
|
||||
procedure Test.70 (Test.71, Test.265):
|
||||
let Test.72 : Str = StructAtIndex 0 Test.265;
|
||||
let Test.73 : Str = StructAtIndex 1 Test.265;
|
||||
let Test.269 : Str = CallByName Test.19 Test.72;
|
||||
let Test.270 : {} = Struct {};
|
||||
let Test.267 : List U8 = CallByName Encode.24 Test.71 Test.269 Test.270;
|
||||
let Test.268 : {} = Struct {};
|
||||
let Test.266 : List U8 = CallByName Encode.24 Test.267 Test.73 Test.268;
|
||||
ret Test.266;
|
||||
procedure Test.71 (Test.72, Test.266):
|
||||
let Test.73 : Str = StructAtIndex 0 Test.266;
|
||||
let Test.74 : Str = StructAtIndex 1 Test.266;
|
||||
let Test.270 : Str = CallByName Test.20 Test.73;
|
||||
let Test.271 : {} = Struct {};
|
||||
let Test.268 : List U8 = CallByName Encode.24 Test.72 Test.270 Test.271;
|
||||
let Test.269 : {} = Struct {};
|
||||
let Test.267 : List U8 = CallByName Encode.24 Test.268 Test.74 Test.269;
|
||||
ret Test.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.258 : Str = "foo";
|
||||
let Test.256 : {} = CallByName Test.2;
|
||||
let Test.254 : List U8 = CallByName Encode.26 Test.258 Test.256;
|
||||
let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
|
||||
let Test.251 : U8 = 1i64;
|
||||
let Test.252 : U8 = GetTagId Test.209;
|
||||
let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
|
||||
if Test.253 then
|
||||
let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
|
||||
ret Test.210;
|
||||
let Test.259 : Str = "foo";
|
||||
let Test.257 : {} = CallByName Test.3;
|
||||
let Test.255 : List U8 = CallByName Encode.26 Test.259 Test.257;
|
||||
let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
|
||||
let Test.252 : U8 = 1i64;
|
||||
let Test.253 : U8 = GetTagId Test.210;
|
||||
let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
|
||||
if Test.254 then
|
||||
let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
|
||||
ret Test.211;
|
||||
else
|
||||
dec Test.209;
|
||||
let Test.250 : Str = "<bad>";
|
||||
ret Test.250;
|
||||
dec Test.210;
|
||||
let Test.251 : Str = "<bad>";
|
||||
ret Test.251;
|
||||
|
@ -6,203 +6,203 @@ procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
|
||||
let #Derived_gen.11 : Str = "a";
|
||||
let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1;
|
||||
inc #Derived_gen.13;
|
||||
let #Derived_gen.12 : Str = CallByName Test.19 #Derived_gen.13;
|
||||
let #Derived_gen.12 : Str = CallByName Test.20 #Derived_gen.13;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12};
|
||||
let #Derived_gen.8 : Str = "b";
|
||||
let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1;
|
||||
dec #Derived_gen.13;
|
||||
let #Derived_gen.9 : Str = CallByName Test.19 #Derived_gen.10;
|
||||
let #Derived_gen.9 : Str = CallByName Test.20 #Derived_gen.10;
|
||||
let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Test.21 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Test.22 #Derived_gen.5;
|
||||
let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.4 #Derived.4;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName #Derived.2 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.113 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.113 : List U8 = CallByName #Derived.2 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.113;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.119 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.119;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.115 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.115;
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : {Str, Str} = CallByName #Derived.0 Encode.105;
|
||||
let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
|
||||
ret Encode.108;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.121 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.121;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Encode.26 (Encode.107, Encode.108):
|
||||
let Encode.111 : List U8 = Array [];
|
||||
let Encode.112 : {Str, Str} = CallByName #Derived.0 Encode.107;
|
||||
let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
|
||||
ret Encode.110;
|
||||
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : List U8 = CallByName List.70 List.127 List.644;
|
||||
let List.642 : List U8 = CallByName List.71 List.643 List.128;
|
||||
ret List.642;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.647 : U64 = 1i64;
|
||||
let List.646 : List U8 = CallByName List.70 List.130 List.647;
|
||||
let List.645 : List U8 = CallByName List.71 List.646 List.131;
|
||||
ret List.645;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.647;
|
||||
let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.641;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.636;
|
||||
let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.639;
|
||||
|
||||
procedure List.8 (#Attr.2, #Attr.3):
|
||||
let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.646;
|
||||
let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.649;
|
||||
|
||||
procedure List.92 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : List U8 = CallByName Test.70 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : List U8 = CallByName Test.71 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.17;
|
||||
jump List.625 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
|
||||
jump List.628 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.241;
|
||||
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.245;
|
||||
|
||||
procedure Str.36 (#Attr.2):
|
||||
let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.242;
|
||||
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.246;
|
||||
|
||||
procedure Str.43 (#Attr.2):
|
||||
let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.239;
|
||||
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.243;
|
||||
|
||||
procedure Str.9 (Str.67):
|
||||
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
|
||||
let Str.236 : Int1 = StructAtIndex 2 Str.68;
|
||||
if Str.236 then
|
||||
let Str.238 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
|
||||
ret Str.237;
|
||||
procedure Str.9 (Str.71):
|
||||
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
|
||||
let Str.240 : Int1 = StructAtIndex 2 Str.72;
|
||||
if Str.240 then
|
||||
let Str.242 : Str = StructAtIndex 1 Str.72;
|
||||
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
|
||||
ret Str.241;
|
||||
else
|
||||
let Str.234 : U8 = StructAtIndex 3 Str.68;
|
||||
let Str.235 : U64 = StructAtIndex 0 Str.68;
|
||||
let #Derived_gen.28 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.238 : U8 = StructAtIndex 3 Str.72;
|
||||
let Str.239 : U64 = StructAtIndex 0 Str.72;
|
||||
let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
|
||||
dec #Derived_gen.28;
|
||||
let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
|
||||
let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
|
||||
ret Str.232;
|
||||
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
|
||||
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.19 (Test.55):
|
||||
let Test.295 : Str = CallByName Encode.23 Test.55;
|
||||
ret Test.295;
|
||||
procedure Test.20 (Test.56):
|
||||
let Test.296 : Str = CallByName Encode.23 Test.56;
|
||||
ret Test.296;
|
||||
|
||||
procedure Test.2 ():
|
||||
let Test.257 : {} = Struct {};
|
||||
ret Test.257;
|
||||
procedure Test.22 (Test.67):
|
||||
let Test.261 : List {Str, Str} = CallByName Encode.23 Test.67;
|
||||
ret Test.261;
|
||||
|
||||
procedure Test.21 (Test.66):
|
||||
let Test.260 : List {Str, Str} = CallByName Encode.23 Test.66;
|
||||
ret Test.260;
|
||||
procedure Test.3 ():
|
||||
let Test.258 : {} = Struct {};
|
||||
ret Test.258;
|
||||
|
||||
procedure Test.3 (Test.48, Test.49, Test.50):
|
||||
let Test.289 : U8 = CallByName Num.127 Test.49;
|
||||
let Test.286 : List U8 = CallByName List.4 Test.48 Test.289;
|
||||
let Test.288 : Str = CallByName Num.96 Test.50;
|
||||
let Test.287 : List U8 = CallByName Str.12 Test.288;
|
||||
let Test.284 : List U8 = CallByName List.8 Test.286 Test.287;
|
||||
let Test.285 : U8 = 32i64;
|
||||
let Test.283 : List U8 = CallByName List.4 Test.284 Test.285;
|
||||
ret Test.283;
|
||||
procedure Test.4 (Test.49, Test.50, Test.51):
|
||||
let Test.290 : U8 = CallByName Num.127 Test.50;
|
||||
let Test.287 : List U8 = CallByName List.4 Test.49 Test.290;
|
||||
let Test.289 : Str = CallByName Num.96 Test.51;
|
||||
let Test.288 : List U8 = CallByName Str.12 Test.289;
|
||||
let Test.285 : List U8 = CallByName List.8 Test.287 Test.288;
|
||||
let Test.286 : U8 = 32i64;
|
||||
let Test.284 : List U8 = CallByName List.4 Test.285 Test.286;
|
||||
ret Test.284;
|
||||
|
||||
procedure Test.56 (Test.57, Test.274, Test.55):
|
||||
let Test.281 : I64 = 115i64;
|
||||
let Test.282 : U64 = CallByName Str.36 Test.55;
|
||||
let Test.279 : List U8 = CallByName Test.3 Test.57 Test.281 Test.282;
|
||||
let Test.280 : List U8 = CallByName Str.12 Test.55;
|
||||
let Test.277 : List U8 = CallByName List.8 Test.279 Test.280;
|
||||
let Test.278 : U8 = 32i64;
|
||||
let Test.276 : List U8 = CallByName List.4 Test.277 Test.278;
|
||||
ret Test.276;
|
||||
procedure Test.57 (Test.58, Test.275, Test.56):
|
||||
let Test.282 : I64 = 115i64;
|
||||
let Test.283 : U64 = CallByName Str.36 Test.56;
|
||||
let Test.280 : List U8 = CallByName Test.4 Test.58 Test.282 Test.283;
|
||||
let Test.281 : List U8 = CallByName Str.12 Test.56;
|
||||
let Test.278 : List U8 = CallByName List.8 Test.280 Test.281;
|
||||
let Test.279 : U8 = 32i64;
|
||||
let Test.277 : List U8 = CallByName List.4 Test.278 Test.279;
|
||||
ret Test.277;
|
||||
|
||||
procedure Test.67 (Test.68, Test.262, Test.66):
|
||||
let Test.290 : I64 = 114i64;
|
||||
let Test.291 : U64 = CallByName List.6 Test.66;
|
||||
let Test.69 : List U8 = CallByName Test.3 Test.68 Test.290 Test.291;
|
||||
let Test.265 : {} = Struct {};
|
||||
let Test.264 : List U8 = CallByName List.18 Test.66 Test.69 Test.265;
|
||||
ret Test.264;
|
||||
procedure Test.68 (Test.69, Test.263, Test.67):
|
||||
let Test.291 : I64 = 114i64;
|
||||
let Test.292 : U64 = CallByName List.6 Test.67;
|
||||
let Test.70 : List U8 = CallByName Test.4 Test.69 Test.291 Test.292;
|
||||
let Test.266 : {} = Struct {};
|
||||
let Test.265 : List U8 = CallByName List.18 Test.67 Test.70 Test.266;
|
||||
ret Test.265;
|
||||
|
||||
procedure Test.70 (Test.71, Test.266):
|
||||
let Test.72 : Str = StructAtIndex 0 Test.266;
|
||||
let Test.73 : Str = StructAtIndex 1 Test.266;
|
||||
let Test.270 : Str = CallByName Test.19 Test.72;
|
||||
let Test.271 : {} = Struct {};
|
||||
let Test.268 : List U8 = CallByName Encode.24 Test.71 Test.270 Test.271;
|
||||
let Test.269 : {} = Struct {};
|
||||
let Test.267 : List U8 = CallByName Encode.24 Test.268 Test.73 Test.269;
|
||||
ret Test.267;
|
||||
procedure Test.71 (Test.72, Test.267):
|
||||
let Test.73 : Str = StructAtIndex 0 Test.267;
|
||||
let Test.74 : Str = StructAtIndex 1 Test.267;
|
||||
let Test.271 : Str = CallByName Test.20 Test.73;
|
||||
let Test.272 : {} = Struct {};
|
||||
let Test.269 : List U8 = CallByName Encode.24 Test.72 Test.271 Test.272;
|
||||
let Test.270 : {} = Struct {};
|
||||
let Test.268 : List U8 = CallByName Encode.24 Test.269 Test.74 Test.270;
|
||||
ret Test.268;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.258 : Str = "foo";
|
||||
let Test.259 : Str = "bar";
|
||||
let Test.255 : {Str, Str} = Struct {Test.258, Test.259};
|
||||
let Test.256 : {} = CallByName Test.2;
|
||||
let Test.254 : List U8 = CallByName Encode.26 Test.255 Test.256;
|
||||
let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
|
||||
let Test.251 : U8 = 1i64;
|
||||
let Test.252 : U8 = GetTagId Test.209;
|
||||
let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
|
||||
if Test.253 then
|
||||
let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
|
||||
ret Test.210;
|
||||
let Test.259 : Str = "foo";
|
||||
let Test.260 : Str = "bar";
|
||||
let Test.256 : {Str, Str} = Struct {Test.259, Test.260};
|
||||
let Test.257 : {} = CallByName Test.3;
|
||||
let Test.255 : List U8 = CallByName Encode.26 Test.256 Test.257;
|
||||
let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
|
||||
let Test.252 : U8 = 1i64;
|
||||
let Test.253 : U8 = GetTagId Test.210;
|
||||
let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
|
||||
if Test.254 then
|
||||
let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
|
||||
ret Test.211;
|
||||
else
|
||||
dec Test.209;
|
||||
let Test.250 : Str = "<bad>";
|
||||
ret Test.250;
|
||||
dec Test.210;
|
||||
let Test.251 : Str = "<bad>";
|
||||
ret Test.251;
|
||||
|
@ -1,110 +1,110 @@
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.113 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.113;
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : Str = CallByName Test.19 Encode.105;
|
||||
let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
|
||||
ret Encode.108;
|
||||
procedure Encode.26 (Encode.107, Encode.108):
|
||||
let Encode.111 : List U8 = Array [];
|
||||
let Encode.112 : Str = CallByName Test.20 Encode.107;
|
||||
let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
|
||||
ret Encode.110;
|
||||
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.632 : U64 = 1i64;
|
||||
let List.631 : List U8 = CallByName List.70 List.127 List.632;
|
||||
let List.630 : List U8 = CallByName List.71 List.631 List.128;
|
||||
ret List.630;
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.635 : U64 = 1i64;
|
||||
let List.634 : List U8 = CallByName List.70 List.130 List.635;
|
||||
let List.633 : List U8 = CallByName List.71 List.634 List.131;
|
||||
ret List.633;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.626 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.626;
|
||||
let List.629 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.629;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.624 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.624;
|
||||
let List.627 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure List.8 (#Attr.2, #Attr.3):
|
||||
let List.634 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.634;
|
||||
let List.637 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.637;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.280;
|
||||
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.241;
|
||||
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.245;
|
||||
|
||||
procedure Str.36 (#Attr.2):
|
||||
let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.242;
|
||||
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.246;
|
||||
|
||||
procedure Str.43 (#Attr.2):
|
||||
let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.239;
|
||||
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.243;
|
||||
|
||||
procedure Str.9 (Str.67):
|
||||
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
|
||||
let Str.236 : Int1 = StructAtIndex 2 Str.68;
|
||||
if Str.236 then
|
||||
let Str.238 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
|
||||
ret Str.237;
|
||||
procedure Str.9 (Str.71):
|
||||
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
|
||||
let Str.240 : Int1 = StructAtIndex 2 Str.72;
|
||||
if Str.240 then
|
||||
let Str.242 : Str = StructAtIndex 1 Str.72;
|
||||
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
|
||||
ret Str.241;
|
||||
else
|
||||
let Str.234 : U8 = StructAtIndex 3 Str.68;
|
||||
let Str.235 : U64 = StructAtIndex 0 Str.68;
|
||||
let #Derived_gen.3 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.238 : U8 = StructAtIndex 3 Str.72;
|
||||
let Str.239 : U64 = StructAtIndex 0 Str.72;
|
||||
let #Derived_gen.3 : Str = StructAtIndex 1 Str.72;
|
||||
dec #Derived_gen.3;
|
||||
let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
|
||||
let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
|
||||
ret Str.232;
|
||||
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
|
||||
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.19 (Test.55):
|
||||
let Test.258 : Str = CallByName Encode.23 Test.55;
|
||||
procedure Test.20 (Test.56):
|
||||
let Test.259 : Str = CallByName Encode.23 Test.56;
|
||||
ret Test.259;
|
||||
|
||||
procedure Test.3 ():
|
||||
let Test.258 : {} = Struct {};
|
||||
ret Test.258;
|
||||
|
||||
procedure Test.2 ():
|
||||
let Test.257 : {} = Struct {};
|
||||
ret Test.257;
|
||||
procedure Test.4 (Test.49, Test.50, Test.51):
|
||||
let Test.276 : U8 = CallByName Num.127 Test.50;
|
||||
let Test.273 : List U8 = CallByName List.4 Test.49 Test.276;
|
||||
let Test.275 : Str = CallByName Num.96 Test.51;
|
||||
let Test.274 : List U8 = CallByName Str.12 Test.275;
|
||||
let Test.271 : List U8 = CallByName List.8 Test.273 Test.274;
|
||||
let Test.272 : U8 = 32i64;
|
||||
let Test.270 : List U8 = CallByName List.4 Test.271 Test.272;
|
||||
ret Test.270;
|
||||
|
||||
procedure Test.3 (Test.48, Test.49, Test.50):
|
||||
let Test.275 : U8 = CallByName Num.127 Test.49;
|
||||
let Test.272 : List U8 = CallByName List.4 Test.48 Test.275;
|
||||
let Test.274 : Str = CallByName Num.96 Test.50;
|
||||
let Test.273 : List U8 = CallByName Str.12 Test.274;
|
||||
let Test.270 : List U8 = CallByName List.8 Test.272 Test.273;
|
||||
let Test.271 : U8 = 32i64;
|
||||
let Test.269 : List U8 = CallByName List.4 Test.270 Test.271;
|
||||
ret Test.269;
|
||||
|
||||
procedure Test.56 (Test.57, Test.260, Test.55):
|
||||
let Test.267 : I64 = 115i64;
|
||||
let Test.268 : U64 = CallByName Str.36 Test.55;
|
||||
let Test.265 : List U8 = CallByName Test.3 Test.57 Test.267 Test.268;
|
||||
let Test.266 : List U8 = CallByName Str.12 Test.55;
|
||||
let Test.263 : List U8 = CallByName List.8 Test.265 Test.266;
|
||||
let Test.264 : U8 = 32i64;
|
||||
let Test.262 : List U8 = CallByName List.4 Test.263 Test.264;
|
||||
ret Test.262;
|
||||
procedure Test.57 (Test.58, Test.261, Test.56):
|
||||
let Test.268 : I64 = 115i64;
|
||||
let Test.269 : U64 = CallByName Str.36 Test.56;
|
||||
let Test.266 : List U8 = CallByName Test.4 Test.58 Test.268 Test.269;
|
||||
let Test.267 : List U8 = CallByName Str.12 Test.56;
|
||||
let Test.264 : List U8 = CallByName List.8 Test.266 Test.267;
|
||||
let Test.265 : U8 = 32i64;
|
||||
let Test.263 : List U8 = CallByName List.4 Test.264 Test.265;
|
||||
ret Test.263;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.255 : Str = "abc";
|
||||
let Test.256 : {} = CallByName Test.2;
|
||||
let Test.254 : List U8 = CallByName Encode.26 Test.255 Test.256;
|
||||
let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
|
||||
let Test.251 : U8 = 1i64;
|
||||
let Test.252 : U8 = GetTagId Test.209;
|
||||
let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
|
||||
if Test.253 then
|
||||
let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
|
||||
ret Test.210;
|
||||
let Test.256 : Str = "abc";
|
||||
let Test.257 : {} = CallByName Test.3;
|
||||
let Test.255 : List U8 = CallByName Encode.26 Test.256 Test.257;
|
||||
let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
|
||||
let Test.252 : U8 = 1i64;
|
||||
let Test.253 : U8 = GetTagId Test.210;
|
||||
let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
|
||||
if Test.254 then
|
||||
let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
|
||||
ret Test.211;
|
||||
else
|
||||
dec Test.209;
|
||||
let Test.250 : Str = "<bad>";
|
||||
ret Test.250;
|
||||
dec Test.210;
|
||||
let Test.251 : Str = "<bad>";
|
||||
ret Test.251;
|
||||
|
@ -8,212 +8,212 @@ procedure #Derived.3 (#Derived.4, #Derived.5, #Derived.1):
|
||||
ret #Derived_gen.3;
|
||||
in
|
||||
let #Derived_gen.7 : Str = "A";
|
||||
let #Derived_gen.9 : Str = CallByName Test.19 #Derived.1;
|
||||
let #Derived_gen.9 : Str = CallByName Test.20 #Derived.1;
|
||||
let #Derived_gen.8 : List Str = Array [#Derived_gen.9];
|
||||
let #Derived_gen.6 : {List Str, {}} = CallByName Test.23 #Derived_gen.7 #Derived_gen.8;
|
||||
let #Derived_gen.6 : {List Str, {}} = CallByName Test.24 #Derived_gen.7 #Derived_gen.8;
|
||||
jump #Derived_gen.5 #Derived_gen.6;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName #Derived.3 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.113 : List U8 = CallByName Test.60 Encode.99 Encode.101 Encode.107;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.113 : List U8 = CallByName #Derived.3 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.113;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.117 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.117;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.115 : List U8 = CallByName Test.61 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.115;
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : Str = CallByName #Derived.0 Encode.105;
|
||||
let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
|
||||
ret Encode.108;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.119 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.119;
|
||||
|
||||
procedure Encode.26 (Encode.107, Encode.108):
|
||||
let Encode.111 : List U8 = Array [];
|
||||
let Encode.112 : Str = CallByName #Derived.0 Encode.107;
|
||||
let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
|
||||
ret Encode.110;
|
||||
|
||||
procedure List.13 (#Attr.2, #Attr.3):
|
||||
let List.648 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
|
||||
ret List.648;
|
||||
let List.651 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
|
||||
ret List.651;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : List U8 = CallByName List.70 List.127 List.644;
|
||||
let List.642 : List U8 = CallByName List.71 List.643 List.128;
|
||||
ret List.642;
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.647 : U64 = 1i64;
|
||||
let List.646 : List U8 = CallByName List.70 List.130 List.647;
|
||||
let List.645 : List U8 = CallByName List.71 List.646 List.131;
|
||||
ret List.645;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.647;
|
||||
let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.641;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.636;
|
||||
let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.639;
|
||||
|
||||
procedure List.8 (#Attr.2, #Attr.3):
|
||||
let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.646;
|
||||
let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.649;
|
||||
|
||||
procedure List.92 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : Str = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : List U8 = CallByName Test.63 List.167 List.631 List.168;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : Str = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : List U8 = CallByName Test.64 List.170 List.634 List.171;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.13;
|
||||
jump List.625 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
|
||||
inc #Derived_gen.10;
|
||||
jump List.628 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.241;
|
||||
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.245;
|
||||
|
||||
procedure Str.36 (#Attr.2):
|
||||
let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.242;
|
||||
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.246;
|
||||
|
||||
procedure Str.43 (#Attr.2):
|
||||
let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.239;
|
||||
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.243;
|
||||
|
||||
procedure Str.9 (Str.67):
|
||||
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
|
||||
let Str.236 : Int1 = StructAtIndex 2 Str.68;
|
||||
if Str.236 then
|
||||
let Str.238 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
|
||||
ret Str.237;
|
||||
procedure Str.9 (Str.71):
|
||||
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
|
||||
let Str.240 : Int1 = StructAtIndex 2 Str.72;
|
||||
if Str.240 then
|
||||
let Str.242 : Str = StructAtIndex 1 Str.72;
|
||||
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
|
||||
ret Str.241;
|
||||
else
|
||||
let Str.234 : U8 = StructAtIndex 3 Str.68;
|
||||
let Str.235 : U64 = StructAtIndex 0 Str.68;
|
||||
let #Derived_gen.27 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.238 : U8 = StructAtIndex 3 Str.72;
|
||||
let Str.239 : U64 = StructAtIndex 0 Str.72;
|
||||
let #Derived_gen.27 : Str = StructAtIndex 1 Str.72;
|
||||
dec #Derived_gen.27;
|
||||
let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
|
||||
let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
|
||||
ret Str.232;
|
||||
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
|
||||
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.19 (Test.55):
|
||||
let Test.296 : Str = CallByName Encode.23 Test.55;
|
||||
ret Test.296;
|
||||
procedure Test.20 (Test.56):
|
||||
let Test.297 : Str = CallByName Encode.23 Test.56;
|
||||
ret Test.297;
|
||||
|
||||
procedure Test.2 ():
|
||||
let Test.258 : {} = Struct {};
|
||||
ret Test.258;
|
||||
procedure Test.21 (Test.59, Test.60):
|
||||
inc Test.59;
|
||||
let Test.266 : {List Str, {}} = Struct {Test.59, Test.60};
|
||||
let Test.265 : {List Str, {}} = CallByName Encode.23 Test.266;
|
||||
ret Test.265;
|
||||
|
||||
procedure Test.20 (Test.58, Test.59):
|
||||
inc Test.58;
|
||||
let Test.265 : {List Str, {}} = Struct {Test.58, Test.59};
|
||||
let Test.264 : {List Str, {}} = CallByName Encode.23 Test.265;
|
||||
ret Test.264;
|
||||
procedure Test.23 (Test.75):
|
||||
let Test.264 : {} = Struct {};
|
||||
let Test.263 : {List Str, {}} = CallByName Test.21 Test.75 Test.264;
|
||||
ret Test.263;
|
||||
|
||||
procedure Test.22 (Test.74):
|
||||
let Test.263 : {} = Struct {};
|
||||
let Test.262 : {List Str, {}} = CallByName Test.20 Test.74 Test.263;
|
||||
ret Test.262;
|
||||
procedure Test.24 (Test.78, Test.79):
|
||||
let Test.285 : Str = CallByName Test.20 Test.78;
|
||||
let Test.262 : List Str = CallByName List.13 Test.79 Test.285;
|
||||
let Test.261 : {List Str, {}} = CallByName Test.23 Test.262;
|
||||
dec Test.262;
|
||||
ret Test.261;
|
||||
|
||||
procedure Test.23 (Test.77, Test.78):
|
||||
let Test.284 : Str = CallByName Test.19 Test.77;
|
||||
let Test.261 : List Str = CallByName List.13 Test.78 Test.284;
|
||||
let Test.260 : {List Str, {}} = CallByName Test.22 Test.261;
|
||||
dec Test.261;
|
||||
ret Test.260;
|
||||
procedure Test.3 ():
|
||||
let Test.259 : {} = Struct {};
|
||||
ret Test.259;
|
||||
|
||||
procedure Test.3 (Test.48, Test.49, Test.50):
|
||||
let Test.282 : U8 = CallByName Num.127 Test.49;
|
||||
let Test.279 : List U8 = CallByName List.4 Test.48 Test.282;
|
||||
let Test.281 : Str = CallByName Num.96 Test.50;
|
||||
let Test.280 : List U8 = CallByName Str.12 Test.281;
|
||||
let Test.277 : List U8 = CallByName List.8 Test.279 Test.280;
|
||||
let Test.278 : U8 = 32i64;
|
||||
let Test.276 : List U8 = CallByName List.4 Test.277 Test.278;
|
||||
ret Test.276;
|
||||
procedure Test.4 (Test.49, Test.50, Test.51):
|
||||
let Test.283 : U8 = CallByName Num.127 Test.50;
|
||||
let Test.280 : List U8 = CallByName List.4 Test.49 Test.283;
|
||||
let Test.282 : Str = CallByName Num.96 Test.51;
|
||||
let Test.281 : List U8 = CallByName Str.12 Test.282;
|
||||
let Test.278 : List U8 = CallByName List.8 Test.280 Test.281;
|
||||
let Test.279 : U8 = 32i64;
|
||||
let Test.277 : List U8 = CallByName List.4 Test.278 Test.279;
|
||||
ret Test.277;
|
||||
|
||||
procedure Test.56 (Test.57, Test.287, Test.55):
|
||||
let Test.294 : I64 = 115i64;
|
||||
let Test.295 : U64 = CallByName Str.36 Test.55;
|
||||
let Test.292 : List U8 = CallByName Test.3 Test.57 Test.294 Test.295;
|
||||
let Test.293 : List U8 = CallByName Str.12 Test.55;
|
||||
let Test.290 : List U8 = CallByName List.8 Test.292 Test.293;
|
||||
let Test.291 : U8 = 32i64;
|
||||
let Test.289 : List U8 = CallByName List.4 Test.290 Test.291;
|
||||
ret Test.289;
|
||||
procedure Test.57 (Test.58, Test.288, Test.56):
|
||||
let Test.295 : I64 = 115i64;
|
||||
let Test.296 : U64 = CallByName Str.36 Test.56;
|
||||
let Test.293 : List U8 = CallByName Test.4 Test.58 Test.295 Test.296;
|
||||
let Test.294 : List U8 = CallByName Str.12 Test.56;
|
||||
let Test.291 : List U8 = CallByName List.8 Test.293 Test.294;
|
||||
let Test.292 : U8 = 32i64;
|
||||
let Test.290 : List U8 = CallByName List.4 Test.291 Test.292;
|
||||
ret Test.290;
|
||||
|
||||
procedure Test.60 (Test.61, Test.266, #Attr.12):
|
||||
let Test.59 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Test.58 : List Str = StructAtIndex 0 #Attr.12;
|
||||
let Test.274 : I64 = 108i64;
|
||||
let Test.275 : U64 = CallByName List.6 Test.58;
|
||||
let Test.62 : List U8 = CallByName Test.3 Test.61 Test.274 Test.275;
|
||||
let Test.268 : List U8 = CallByName List.18 Test.58 Test.62 Test.59;
|
||||
dec Test.58;
|
||||
ret Test.268;
|
||||
procedure Test.61 (Test.62, Test.267, #Attr.12):
|
||||
let Test.60 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Test.59 : List Str = StructAtIndex 0 #Attr.12;
|
||||
let Test.275 : I64 = 108i64;
|
||||
let Test.276 : U64 = CallByName List.6 Test.59;
|
||||
let Test.63 : List U8 = CallByName Test.4 Test.62 Test.275 Test.276;
|
||||
let Test.269 : List U8 = CallByName List.18 Test.59 Test.63 Test.60;
|
||||
dec Test.59;
|
||||
ret Test.269;
|
||||
|
||||
procedure Test.63 (Test.64, Test.65, Test.59):
|
||||
let Test.272 : Str = CallByName Test.75 Test.65;
|
||||
let Test.273 : {} = Struct {};
|
||||
let Test.271 : List U8 = CallByName Encode.24 Test.64 Test.272 Test.273;
|
||||
ret Test.271;
|
||||
procedure Test.64 (Test.65, Test.66, Test.60):
|
||||
let Test.273 : Str = CallByName Test.76 Test.66;
|
||||
let Test.274 : {} = Struct {};
|
||||
let Test.272 : List U8 = CallByName Encode.24 Test.65 Test.273 Test.274;
|
||||
ret Test.272;
|
||||
|
||||
procedure Test.75 (Test.76):
|
||||
ret Test.76;
|
||||
procedure Test.76 (Test.77):
|
||||
ret Test.77;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.259 : Str = "foo";
|
||||
let Test.257 : {} = CallByName Test.2;
|
||||
let Test.256 : List U8 = CallByName Encode.26 Test.259 Test.257;
|
||||
let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.256;
|
||||
let Test.253 : U8 = 1i64;
|
||||
let Test.254 : U8 = GetTagId Test.210;
|
||||
let Test.255 : Int1 = lowlevel Eq Test.253 Test.254;
|
||||
if Test.255 then
|
||||
let Test.212 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
|
||||
ret Test.212;
|
||||
let Test.260 : Str = "foo";
|
||||
let Test.258 : {} = CallByName Test.3;
|
||||
let Test.257 : List U8 = CallByName Encode.26 Test.260 Test.258;
|
||||
let Test.211 : [C {U64, U8}, C Str] = CallByName Str.9 Test.257;
|
||||
let Test.254 : U8 = 1i64;
|
||||
let Test.255 : U8 = GetTagId Test.211;
|
||||
let Test.256 : Int1 = lowlevel Eq Test.254 Test.255;
|
||||
if Test.256 then
|
||||
let Test.213 : Str = UnionAtIndex (Id 1) (Index 0) Test.211;
|
||||
ret Test.213;
|
||||
else
|
||||
dec Test.210;
|
||||
let Test.252 : Str = "<bad>";
|
||||
ret Test.252;
|
||||
dec Test.211;
|
||||
let Test.253 : Str = "<bad>";
|
||||
ret Test.253;
|
||||
|
@ -10,215 +10,215 @@ procedure #Derived.4 (#Derived.5, #Derived.6, #Derived.1):
|
||||
let #Derived.2 : Str = StructAtIndex 0 #Derived.1;
|
||||
let #Derived.3 : Str = StructAtIndex 1 #Derived.1;
|
||||
let #Derived_gen.7 : Str = "A";
|
||||
let #Derived_gen.9 : Str = CallByName Test.19 #Derived.2;
|
||||
let #Derived_gen.10 : Str = CallByName Test.19 #Derived.3;
|
||||
let #Derived_gen.9 : Str = CallByName Test.20 #Derived.2;
|
||||
let #Derived_gen.10 : Str = CallByName Test.20 #Derived.3;
|
||||
let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10];
|
||||
let #Derived_gen.6 : {List Str, {}} = CallByName Test.23 #Derived_gen.7 #Derived_gen.8;
|
||||
let #Derived_gen.6 : {List Str, {}} = CallByName Test.24 #Derived_gen.7 #Derived_gen.8;
|
||||
jump #Derived_gen.5 #Derived_gen.6;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.23 (Encode.98):
|
||||
ret Encode.98;
|
||||
procedure Encode.23 (Encode.100):
|
||||
ret Encode.100;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.111 : List U8 = CallByName #Derived.4 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.111;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.113 : List U8 = CallByName Test.60 Encode.99 Encode.101 Encode.107;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.113 : List U8 = CallByName #Derived.4 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.113;
|
||||
|
||||
procedure Encode.24 (Encode.99, Encode.107, Encode.101):
|
||||
let Encode.118 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
|
||||
ret Encode.118;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.115 : List U8 = CallByName Test.61 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.115;
|
||||
|
||||
procedure Encode.26 (Encode.105, Encode.106):
|
||||
let Encode.109 : List U8 = Array [];
|
||||
let Encode.110 : {Str, Str} = CallByName #Derived.0 Encode.105;
|
||||
let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
|
||||
ret Encode.108;
|
||||
procedure Encode.24 (Encode.101, Encode.109, Encode.103):
|
||||
let Encode.120 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
|
||||
ret Encode.120;
|
||||
|
||||
procedure Encode.26 (Encode.107, Encode.108):
|
||||
let Encode.111 : List U8 = Array [];
|
||||
let Encode.112 : {Str, Str} = CallByName #Derived.0 Encode.107;
|
||||
let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
|
||||
ret Encode.110;
|
||||
|
||||
procedure List.13 (#Attr.2, #Attr.3):
|
||||
let List.648 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
|
||||
ret List.648;
|
||||
let List.651 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
|
||||
ret List.651;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : List U8 = CallByName List.70 List.127 List.644;
|
||||
let List.642 : List U8 = CallByName List.71 List.643 List.128;
|
||||
ret List.642;
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.647 : U64 = 1i64;
|
||||
let List.646 : List U8 = CallByName List.70 List.130 List.647;
|
||||
let List.645 : List U8 = CallByName List.71 List.646 List.131;
|
||||
ret List.645;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.647;
|
||||
let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.641;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.636;
|
||||
let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.639;
|
||||
|
||||
procedure List.8 (#Attr.2, #Attr.3):
|
||||
let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.646;
|
||||
let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
|
||||
ret List.649;
|
||||
|
||||
procedure List.92 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : Str = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : List U8 = CallByName Test.63 List.167 List.631 List.168;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : Str = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : List U8 = CallByName Test.64 List.170 List.634 List.171;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.14;
|
||||
jump List.625 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
|
||||
inc #Derived_gen.11;
|
||||
jump List.628 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.241;
|
||||
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.245;
|
||||
|
||||
procedure Str.36 (#Attr.2):
|
||||
let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.242;
|
||||
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
|
||||
ret Str.246;
|
||||
|
||||
procedure Str.43 (#Attr.2):
|
||||
let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.239;
|
||||
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
|
||||
ret Str.243;
|
||||
|
||||
procedure Str.9 (Str.67):
|
||||
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
|
||||
let Str.236 : Int1 = StructAtIndex 2 Str.68;
|
||||
if Str.236 then
|
||||
let Str.238 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
|
||||
ret Str.237;
|
||||
procedure Str.9 (Str.71):
|
||||
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
|
||||
let Str.240 : Int1 = StructAtIndex 2 Str.72;
|
||||
if Str.240 then
|
||||
let Str.242 : Str = StructAtIndex 1 Str.72;
|
||||
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
|
||||
ret Str.241;
|
||||
else
|
||||
let Str.234 : U8 = StructAtIndex 3 Str.68;
|
||||
let Str.235 : U64 = StructAtIndex 0 Str.68;
|
||||
let #Derived_gen.28 : Str = StructAtIndex 1 Str.68;
|
||||
let Str.238 : U8 = StructAtIndex 3 Str.72;
|
||||
let Str.239 : U64 = StructAtIndex 0 Str.72;
|
||||
let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
|
||||
dec #Derived_gen.28;
|
||||
let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
|
||||
let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
|
||||
ret Str.232;
|
||||
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
|
||||
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.19 (Test.55):
|
||||
let Test.300 : Str = CallByName Encode.23 Test.55;
|
||||
ret Test.300;
|
||||
procedure Test.20 (Test.56):
|
||||
let Test.301 : Str = CallByName Encode.23 Test.56;
|
||||
ret Test.301;
|
||||
|
||||
procedure Test.2 ():
|
||||
let Test.258 : {} = Struct {};
|
||||
ret Test.258;
|
||||
procedure Test.21 (Test.59, Test.60):
|
||||
inc Test.59;
|
||||
let Test.267 : {List Str, {}} = Struct {Test.59, Test.60};
|
||||
let Test.266 : {List Str, {}} = CallByName Encode.23 Test.267;
|
||||
ret Test.266;
|
||||
|
||||
procedure Test.20 (Test.58, Test.59):
|
||||
inc Test.58;
|
||||
let Test.266 : {List Str, {}} = Struct {Test.58, Test.59};
|
||||
let Test.265 : {List Str, {}} = CallByName Encode.23 Test.266;
|
||||
ret Test.265;
|
||||
procedure Test.23 (Test.75):
|
||||
let Test.265 : {} = Struct {};
|
||||
let Test.264 : {List Str, {}} = CallByName Test.21 Test.75 Test.265;
|
||||
ret Test.264;
|
||||
|
||||
procedure Test.22 (Test.74):
|
||||
let Test.264 : {} = Struct {};
|
||||
let Test.263 : {List Str, {}} = CallByName Test.20 Test.74 Test.264;
|
||||
ret Test.263;
|
||||
procedure Test.24 (Test.78, Test.79):
|
||||
let Test.286 : Str = CallByName Test.20 Test.78;
|
||||
let Test.263 : List Str = CallByName List.13 Test.79 Test.286;
|
||||
let Test.262 : {List Str, {}} = CallByName Test.23 Test.263;
|
||||
dec Test.263;
|
||||
ret Test.262;
|
||||
|
||||
procedure Test.23 (Test.77, Test.78):
|
||||
let Test.285 : Str = CallByName Test.19 Test.77;
|
||||
let Test.262 : List Str = CallByName List.13 Test.78 Test.285;
|
||||
let Test.261 : {List Str, {}} = CallByName Test.22 Test.262;
|
||||
dec Test.262;
|
||||
ret Test.261;
|
||||
procedure Test.3 ():
|
||||
let Test.259 : {} = Struct {};
|
||||
ret Test.259;
|
||||
|
||||
procedure Test.3 (Test.48, Test.49, Test.50):
|
||||
let Test.283 : U8 = CallByName Num.127 Test.49;
|
||||
let Test.280 : List U8 = CallByName List.4 Test.48 Test.283;
|
||||
let Test.282 : Str = CallByName Num.96 Test.50;
|
||||
let Test.281 : List U8 = CallByName Str.12 Test.282;
|
||||
let Test.278 : List U8 = CallByName List.8 Test.280 Test.281;
|
||||
let Test.279 : U8 = 32i64;
|
||||
let Test.277 : List U8 = CallByName List.4 Test.278 Test.279;
|
||||
ret Test.277;
|
||||
procedure Test.4 (Test.49, Test.50, Test.51):
|
||||
let Test.284 : U8 = CallByName Num.127 Test.50;
|
||||
let Test.281 : List U8 = CallByName List.4 Test.49 Test.284;
|
||||
let Test.283 : Str = CallByName Num.96 Test.51;
|
||||
let Test.282 : List U8 = CallByName Str.12 Test.283;
|
||||
let Test.279 : List U8 = CallByName List.8 Test.281 Test.282;
|
||||
let Test.280 : U8 = 32i64;
|
||||
let Test.278 : List U8 = CallByName List.4 Test.279 Test.280;
|
||||
ret Test.278;
|
||||
|
||||
procedure Test.56 (Test.57, Test.288, Test.55):
|
||||
let Test.295 : I64 = 115i64;
|
||||
let Test.296 : U64 = CallByName Str.36 Test.55;
|
||||
let Test.293 : List U8 = CallByName Test.3 Test.57 Test.295 Test.296;
|
||||
let Test.294 : List U8 = CallByName Str.12 Test.55;
|
||||
let Test.291 : List U8 = CallByName List.8 Test.293 Test.294;
|
||||
let Test.292 : U8 = 32i64;
|
||||
let Test.290 : List U8 = CallByName List.4 Test.291 Test.292;
|
||||
ret Test.290;
|
||||
procedure Test.57 (Test.58, Test.289, Test.56):
|
||||
let Test.296 : I64 = 115i64;
|
||||
let Test.297 : U64 = CallByName Str.36 Test.56;
|
||||
let Test.294 : List U8 = CallByName Test.4 Test.58 Test.296 Test.297;
|
||||
let Test.295 : List U8 = CallByName Str.12 Test.56;
|
||||
let Test.292 : List U8 = CallByName List.8 Test.294 Test.295;
|
||||
let Test.293 : U8 = 32i64;
|
||||
let Test.291 : List U8 = CallByName List.4 Test.292 Test.293;
|
||||
ret Test.291;
|
||||
|
||||
procedure Test.60 (Test.61, Test.267, #Attr.12):
|
||||
let Test.59 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Test.58 : List Str = StructAtIndex 0 #Attr.12;
|
||||
let Test.275 : I64 = 108i64;
|
||||
let Test.276 : U64 = CallByName List.6 Test.58;
|
||||
let Test.62 : List U8 = CallByName Test.3 Test.61 Test.275 Test.276;
|
||||
let Test.269 : List U8 = CallByName List.18 Test.58 Test.62 Test.59;
|
||||
dec Test.58;
|
||||
ret Test.269;
|
||||
procedure Test.61 (Test.62, Test.268, #Attr.12):
|
||||
let Test.60 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Test.59 : List Str = StructAtIndex 0 #Attr.12;
|
||||
let Test.276 : I64 = 108i64;
|
||||
let Test.277 : U64 = CallByName List.6 Test.59;
|
||||
let Test.63 : List U8 = CallByName Test.4 Test.62 Test.276 Test.277;
|
||||
let Test.270 : List U8 = CallByName List.18 Test.59 Test.63 Test.60;
|
||||
dec Test.59;
|
||||
ret Test.270;
|
||||
|
||||
procedure Test.63 (Test.64, Test.65, Test.59):
|
||||
let Test.273 : Str = CallByName Test.75 Test.65;
|
||||
let Test.274 : {} = Struct {};
|
||||
let Test.272 : List U8 = CallByName Encode.24 Test.64 Test.273 Test.274;
|
||||
ret Test.272;
|
||||
procedure Test.64 (Test.65, Test.66, Test.60):
|
||||
let Test.274 : Str = CallByName Test.76 Test.66;
|
||||
let Test.275 : {} = Struct {};
|
||||
let Test.273 : List U8 = CallByName Encode.24 Test.65 Test.274 Test.275;
|
||||
ret Test.273;
|
||||
|
||||
procedure Test.75 (Test.76):
|
||||
ret Test.76;
|
||||
procedure Test.76 (Test.77):
|
||||
ret Test.77;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.261 : Str = "foo";
|
||||
let Test.260 : Str = "foo";
|
||||
let Test.259 : Str = "foo";
|
||||
let Test.209 : {Str, Str} = Struct {Test.259, Test.260};
|
||||
let Test.257 : {} = CallByName Test.2;
|
||||
let Test.256 : List U8 = CallByName Encode.26 Test.209 Test.257;
|
||||
let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.256;
|
||||
let Test.253 : U8 = 1i64;
|
||||
let Test.254 : U8 = GetTagId Test.210;
|
||||
let Test.255 : Int1 = lowlevel Eq Test.253 Test.254;
|
||||
if Test.255 then
|
||||
let Test.212 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
|
||||
ret Test.212;
|
||||
let Test.210 : {Str, Str} = Struct {Test.260, Test.261};
|
||||
let Test.258 : {} = CallByName Test.3;
|
||||
let Test.257 : List U8 = CallByName Encode.26 Test.210 Test.258;
|
||||
let Test.211 : [C {U64, U8}, C Str] = CallByName Str.9 Test.257;
|
||||
let Test.254 : U8 = 1i64;
|
||||
let Test.255 : U8 = GetTagId Test.211;
|
||||
let Test.256 : Int1 = lowlevel Eq Test.254 Test.255;
|
||||
if Test.256 then
|
||||
let Test.213 : Str = UnionAtIndex (Id 1) (Index 0) Test.211;
|
||||
ret Test.213;
|
||||
else
|
||||
dec Test.210;
|
||||
let Test.252 : Str = "<bad>";
|
||||
ret Test.252;
|
||||
dec Test.211;
|
||||
let Test.253 : Str = "<bad>";
|
||||
ret Test.253;
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.280 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
|
||||
joinpoint Test.7 Test.2 Test.3:
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.1 (Test.8):
|
||||
let Test.3 : I64 = 10i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.1 (Test.9):
|
||||
let Test.4 : U8 = 10i64;
|
||||
|
@ -3,8 +3,8 @@ procedure Bool.1 ():
|
||||
ret Bool.23;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.3 (Test.4):
|
||||
ret Test.4;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
switch Test.3:
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.280 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.2 (Test.3, Test.1):
|
||||
let Test.18 : Int1 = false;
|
||||
|
2148
crates/compiler/test_mono/generated/inspect_derived_dict.txt
generated
2148
crates/compiler/test_mono/generated/inspect_derived_dict.txt
generated
File diff suppressed because it is too large
Load Diff
@ -3,13 +3,13 @@ procedure #Derived.0 (#Derived.1):
|
||||
ret #Derived_gen.0;
|
||||
|
||||
procedure #Derived.3 (#Derived.2):
|
||||
let #Derived_gen.7 : I64 = CallByName Inspect.53 #Derived.2;
|
||||
let #Derived_gen.7 : I64 = CallByName Inspect.57 #Derived.2;
|
||||
ret #Derived_gen.7;
|
||||
|
||||
procedure #Derived.4 (#Derived.5, #Derived.1):
|
||||
let #Derived_gen.5 : {} = Struct {};
|
||||
let #Derived_gen.6 : {} = Struct {};
|
||||
let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.36 #Derived.1 #Derived_gen.5 #Derived_gen.6;
|
||||
let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.40 #Derived.1 #Derived_gen.5 #Derived_gen.6;
|
||||
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.5;
|
||||
ret #Derived_gen.3;
|
||||
|
||||
@ -21,165 +21,165 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.152 (Inspect.153, #Attr.12):
|
||||
let Inspect.151 : {} = StructAtIndex 2 #Attr.12;
|
||||
let Inspect.150 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Inspect.149 : List I64 = StructAtIndex 0 #Attr.12;
|
||||
let Inspect.343 : Str = "[";
|
||||
let Inspect.324 : Str = CallByName Inspect.59 Inspect.153 Inspect.343;
|
||||
dec Inspect.343;
|
||||
let Inspect.325 : {List I64, {}, {}} = Struct {Inspect.149, Inspect.150, Inspect.151};
|
||||
let Inspect.320 : {Str, Int1} = CallByName Inspect.154 Inspect.324 Inspect.325;
|
||||
dec Inspect.324;
|
||||
let Inspect.321 : {} = Struct {};
|
||||
let Inspect.316 : Str = CallByName Inspect.163 Inspect.320;
|
||||
let Inspect.317 : Str = "]";
|
||||
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
|
||||
dec Inspect.317;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.154 (Inspect.155, #Attr.12):
|
||||
let Inspect.151 : {} = StructAtIndex 2 #Attr.12;
|
||||
let Inspect.150 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Inspect.149 : List I64 = StructAtIndex 0 #Attr.12;
|
||||
let Inspect.342 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.155;
|
||||
let Inspect.328 : {Str, Int1} = Struct {Inspect.155, Inspect.342};
|
||||
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.149 Inspect.328 Inspect.151;
|
||||
dec Inspect.149;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.156 (Inspect.330, Inspect.159, Inspect.151):
|
||||
let Inspect.157 : Str = StructAtIndex 0 Inspect.330;
|
||||
let Inspect.158 : Int1 = StructAtIndex 1 Inspect.330;
|
||||
joinpoint Inspect.340 Inspect.160:
|
||||
let Inspect.337 : I64 = CallByName #Derived.3 Inspect.159;
|
||||
let Inspect.333 : Str = CallByName Inspect.31 Inspect.337 Inspect.160;
|
||||
let Inspect.334 : {} = Struct {};
|
||||
let Inspect.332 : {Str, Int1} = CallByName Inspect.161 Inspect.333;
|
||||
dec Inspect.333;
|
||||
ret Inspect.332;
|
||||
in
|
||||
if Inspect.158 then
|
||||
let Inspect.341 : Str = ", ";
|
||||
let Inspect.339 : Str = CallByName Inspect.59 Inspect.157 Inspect.341;
|
||||
dec Inspect.341;
|
||||
jump Inspect.340 Inspect.339;
|
||||
else
|
||||
jump Inspect.340 Inspect.157;
|
||||
|
||||
procedure Inspect.161 (Inspect.162):
|
||||
let Inspect.336 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.162;
|
||||
let Inspect.335 : {Str, Int1} = Struct {Inspect.162, Inspect.336};
|
||||
ret Inspect.335;
|
||||
|
||||
procedure Inspect.163 (Inspect.322):
|
||||
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.274 (Inspect.275, Inspect.273):
|
||||
let Inspect.349 : Str = CallByName Num.96 Inspect.273;
|
||||
let Inspect.348 : Str = CallByName Inspect.59 Inspect.275 Inspect.349;
|
||||
dec Inspect.349;
|
||||
ret Inspect.348;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.310 : Str = CallByName Inspect.152 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.338 : Str = CallByName Inspect.274 Inspect.145 Inspect.299;
|
||||
ret Inspect.338;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.36 (Inspect.149, Inspect.150, Inspect.151):
|
||||
inc Inspect.149;
|
||||
let Inspect.312 : {List I64, {}, {}} = Struct {Inspect.149, Inspect.150, Inspect.151};
|
||||
let Inspect.311 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.312;
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : List I64 = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.4 Inspect.304 Inspect.308;
|
||||
dec Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.53 (Inspect.273):
|
||||
let Inspect.344 : I64 = CallByName Inspect.30 Inspect.273;
|
||||
ret Inspect.344;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.156 (Inspect.157, #Attr.12):
|
||||
let Inspect.155 : {} = StructAtIndex 2 #Attr.12;
|
||||
let Inspect.154 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Inspect.153 : List I64 = StructAtIndex 0 #Attr.12;
|
||||
let Inspect.347 : Str = "[";
|
||||
let Inspect.328 : Str = CallByName Inspect.63 Inspect.157 Inspect.347;
|
||||
dec Inspect.347;
|
||||
let Inspect.329 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
|
||||
let Inspect.324 : {Str, Int1} = CallByName Inspect.158 Inspect.328 Inspect.329;
|
||||
dec Inspect.328;
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.320 : Str = CallByName Inspect.167 Inspect.324;
|
||||
let Inspect.321 : Str = "]";
|
||||
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
|
||||
dec Inspect.321;
|
||||
ret Inspect.319;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.158 (Inspect.159, #Attr.12):
|
||||
let Inspect.155 : {} = StructAtIndex 2 #Attr.12;
|
||||
let Inspect.154 : {} = StructAtIndex 1 #Attr.12;
|
||||
let Inspect.153 : List I64 = StructAtIndex 0 #Attr.12;
|
||||
let Inspect.346 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.159;
|
||||
let Inspect.332 : {Str, Int1} = Struct {Inspect.159, Inspect.346};
|
||||
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.153 Inspect.332 Inspect.155;
|
||||
dec Inspect.153;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.160 (Inspect.334, Inspect.163, Inspect.155):
|
||||
let Inspect.161 : Str = StructAtIndex 0 Inspect.334;
|
||||
let Inspect.162 : Int1 = StructAtIndex 1 Inspect.334;
|
||||
joinpoint Inspect.344 Inspect.164:
|
||||
let Inspect.341 : I64 = CallByName #Derived.3 Inspect.163;
|
||||
let Inspect.337 : Str = CallByName Inspect.31 Inspect.341 Inspect.164;
|
||||
let Inspect.338 : {} = Struct {};
|
||||
let Inspect.336 : {Str, Int1} = CallByName Inspect.165 Inspect.337;
|
||||
dec Inspect.337;
|
||||
ret Inspect.336;
|
||||
in
|
||||
if Inspect.162 then
|
||||
let Inspect.345 : Str = ", ";
|
||||
let Inspect.343 : Str = CallByName Inspect.63 Inspect.161 Inspect.345;
|
||||
dec Inspect.345;
|
||||
jump Inspect.344 Inspect.343;
|
||||
else
|
||||
jump Inspect.344 Inspect.161;
|
||||
|
||||
procedure Inspect.165 (Inspect.166):
|
||||
let Inspect.340 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.166;
|
||||
let Inspect.339 : {Str, Int1} = Struct {Inspect.166, Inspect.340};
|
||||
ret Inspect.339;
|
||||
|
||||
procedure Inspect.167 (Inspect.326):
|
||||
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.278 (Inspect.279, Inspect.277):
|
||||
let Inspect.353 : Str = CallByName Num.96 Inspect.277;
|
||||
let Inspect.352 : Str = CallByName Inspect.63 Inspect.279 Inspect.353;
|
||||
dec Inspect.353;
|
||||
ret Inspect.352;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.314 : Str = CallByName Inspect.156 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.342 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
|
||||
ret Inspect.342;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.40 (Inspect.153, Inspect.154, Inspect.155):
|
||||
inc Inspect.153;
|
||||
let Inspect.316 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
|
||||
let Inspect.315 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.316;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : List I64 = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312;
|
||||
dec Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.57 (Inspect.277):
|
||||
let Inspect.348 : I64 = CallByName Inspect.30 Inspect.277;
|
||||
ret Inspect.348;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : I64 = CallByName List.66 List.166 List.169;
|
||||
let List.171 : {Str, Int1} = CallByName Inspect.156 List.167 List.631 List.168;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : I64 = CallByName List.66 List.169 List.172;
|
||||
let List.174 : {Str, Int1} = CallByName Inspect.160 List.170 List.634 List.171;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.19;
|
||||
jump List.625 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
|
||||
jump List.628 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
@ -7,7 +7,7 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
|
||||
let #Derived_gen.8 : Str = CallByName #Derived.4 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.5;
|
||||
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
@ -18,10 +18,10 @@ procedure #Derived.4 (#Derived.5):
|
||||
|
||||
procedure #Derived.6 (#Derived.7, #Derived.5):
|
||||
let #Derived_gen.17 : Str = "b";
|
||||
let #Derived_gen.18 : Str = CallByName Inspect.43 #Derived.5;
|
||||
let #Derived_gen.18 : Str = CallByName Inspect.47 #Derived.5;
|
||||
let #Derived_gen.16 : {Str, Str} = Struct {#Derived_gen.17, #Derived_gen.18};
|
||||
let #Derived_gen.15 : List {Str, Str} = Array [#Derived_gen.16];
|
||||
let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.15;
|
||||
let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.15;
|
||||
let #Derived_gen.13 : Str = CallByName Inspect.31 #Derived_gen.14 #Derived.7;
|
||||
dec #Derived_gen.14;
|
||||
ret #Derived_gen.13;
|
||||
@ -34,266 +34,266 @@ procedure Bool.2 ():
|
||||
let Bool.25 : Int1 = true;
|
||||
ret Bool.25;
|
||||
|
||||
procedure Inspect.225 (Inspect.226, Inspect.224):
|
||||
let Inspect.348 : Str = "{";
|
||||
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
|
||||
dec Inspect.348;
|
||||
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
|
||||
dec Inspect.324;
|
||||
let Inspect.321 : {} = Struct {};
|
||||
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
|
||||
let Inspect.317 : Str = "}";
|
||||
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
|
||||
dec Inspect.317;
|
||||
ret Inspect.315;
|
||||
procedure Inspect.229 (Inspect.230, Inspect.228):
|
||||
let Inspect.352 : Str = "{";
|
||||
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
|
||||
dec Inspect.352;
|
||||
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
|
||||
dec Inspect.328;
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
|
||||
let Inspect.321 : Str = "}";
|
||||
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
|
||||
dec Inspect.321;
|
||||
ret Inspect.319;
|
||||
|
||||
procedure Inspect.225 (Inspect.226, Inspect.224):
|
||||
let Inspect.388 : Str = "{";
|
||||
let Inspect.364 : Str = CallByName Inspect.59 Inspect.226 Inspect.388;
|
||||
dec Inspect.388;
|
||||
let Inspect.360 : {Str, Int1} = CallByName Inspect.227 Inspect.364 Inspect.224;
|
||||
dec Inspect.364;
|
||||
let Inspect.361 : {} = Struct {};
|
||||
let Inspect.356 : Str = CallByName Inspect.239 Inspect.360;
|
||||
let Inspect.357 : Str = "}";
|
||||
let Inspect.355 : Str = CallByName Inspect.59 Inspect.356 Inspect.357;
|
||||
dec Inspect.357;
|
||||
ret Inspect.355;
|
||||
|
||||
procedure Inspect.227 (Inspect.228, Inspect.224):
|
||||
let Inspect.347 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.228;
|
||||
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
|
||||
let Inspect.329 : {} = Struct {};
|
||||
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.227 (Inspect.228, Inspect.224):
|
||||
let Inspect.387 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.228;
|
||||
let Inspect.368 : {Str, Int1} = Struct {Inspect.228, Inspect.387};
|
||||
let Inspect.369 : {} = Struct {};
|
||||
let Inspect.367 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.368 Inspect.369;
|
||||
ret Inspect.367;
|
||||
|
||||
procedure Inspect.229 (Inspect.330, Inspect.331):
|
||||
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
|
||||
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
|
||||
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
|
||||
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
|
||||
joinpoint Inspect.345 Inspect.234:
|
||||
let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
|
||||
dec Inspect.232;
|
||||
let Inspect.343 : Str = ": ";
|
||||
let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
|
||||
dec Inspect.343;
|
||||
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
|
||||
let Inspect.334 : {} = Struct {};
|
||||
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
|
||||
dec Inspect.333;
|
||||
ret Inspect.332;
|
||||
in
|
||||
if Inspect.231 then
|
||||
let Inspect.346 : Str = ", ";
|
||||
let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
|
||||
dec Inspect.346;
|
||||
jump Inspect.345 Inspect.344;
|
||||
else
|
||||
jump Inspect.345 Inspect.230;
|
||||
|
||||
procedure Inspect.229 (Inspect.330, Inspect.331):
|
||||
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
|
||||
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
|
||||
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
|
||||
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
|
||||
joinpoint Inspect.385 Inspect.234:
|
||||
let Inspect.382 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
|
||||
dec Inspect.232;
|
||||
let Inspect.383 : Str = ": ";
|
||||
let Inspect.377 : Str = CallByName Inspect.59 Inspect.382 Inspect.383;
|
||||
dec Inspect.383;
|
||||
let Inspect.373 : Str = CallByName Inspect.235 Inspect.377 Inspect.233;
|
||||
dec Inspect.233;
|
||||
let Inspect.374 : {} = Struct {};
|
||||
let Inspect.372 : {Str, Int1} = CallByName Inspect.237 Inspect.373;
|
||||
dec Inspect.373;
|
||||
ret Inspect.372;
|
||||
in
|
||||
if Inspect.231 then
|
||||
let Inspect.386 : Str = ", ";
|
||||
let Inspect.384 : Str = CallByName Inspect.59 Inspect.230 Inspect.386;
|
||||
dec Inspect.386;
|
||||
jump Inspect.385 Inspect.384;
|
||||
else
|
||||
jump Inspect.385 Inspect.230;
|
||||
|
||||
procedure Inspect.235 (Inspect.236, Inspect.233):
|
||||
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
|
||||
ret Inspect.340;
|
||||
|
||||
procedure Inspect.235 (Inspect.236, Inspect.233):
|
||||
let Inspect.380 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
|
||||
ret Inspect.380;
|
||||
|
||||
procedure Inspect.237 (Inspect.238):
|
||||
let Inspect.376 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.238;
|
||||
let Inspect.375 : {Str, Int1} = Struct {Inspect.238, Inspect.376};
|
||||
ret Inspect.375;
|
||||
|
||||
procedure Inspect.239 (Inspect.322):
|
||||
let Inspect.363 : Str = StructAtIndex 0 Inspect.322;
|
||||
ret Inspect.363;
|
||||
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
let Inspect.397 : Str = "\"";
|
||||
let Inspect.396 : Str = CallByName Inspect.59 Inspect.247 Inspect.397;
|
||||
dec Inspect.397;
|
||||
let Inspect.394 : Str = CallByName Inspect.59 Inspect.396 Inspect.245;
|
||||
let Inspect.395 : Str = "\"";
|
||||
let Inspect.393 : Str = CallByName Inspect.59 Inspect.394 Inspect.395;
|
||||
dec Inspect.395;
|
||||
ret Inspect.393;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.341 : Str = CallByName #Derived.6 Inspect.145 Inspect.299;
|
||||
ret Inspect.341;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.350 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
|
||||
ret Inspect.350;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.381 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
|
||||
ret Inspect.381;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.41 (Inspect.224):
|
||||
let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.41 (Inspect.224):
|
||||
let Inspect.351 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
|
||||
ret Inspect.351;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.389 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.389;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.359 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.229 (Inspect.230, Inspect.228):
|
||||
let Inspect.392 : Str = "{";
|
||||
let Inspect.368 : Str = CallByName Inspect.63 Inspect.230 Inspect.392;
|
||||
dec Inspect.392;
|
||||
let Inspect.364 : {Str, Int1} = CallByName Inspect.231 Inspect.368 Inspect.228;
|
||||
dec Inspect.368;
|
||||
let Inspect.365 : {} = Struct {};
|
||||
let Inspect.360 : Str = CallByName Inspect.243 Inspect.364;
|
||||
let Inspect.361 : Str = "}";
|
||||
let Inspect.359 : Str = CallByName Inspect.63 Inspect.360 Inspect.361;
|
||||
dec Inspect.361;
|
||||
ret Inspect.359;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.231 (Inspect.232, Inspect.228):
|
||||
let Inspect.351 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.232;
|
||||
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
|
||||
let Inspect.333 : {} = Struct {};
|
||||
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.231 (Inspect.232, Inspect.228):
|
||||
let Inspect.391 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.232;
|
||||
let Inspect.372 : {Str, Int1} = Struct {Inspect.232, Inspect.391};
|
||||
let Inspect.373 : {} = Struct {};
|
||||
let Inspect.371 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.372 Inspect.373;
|
||||
ret Inspect.371;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.635 : U64 = 0i64;
|
||||
let List.636 : U64 = CallByName List.6 List.163;
|
||||
let List.634 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.635 List.636;
|
||||
ret List.634;
|
||||
procedure Inspect.233 (Inspect.334, Inspect.335):
|
||||
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
|
||||
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
|
||||
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
|
||||
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
|
||||
joinpoint Inspect.349 Inspect.238:
|
||||
let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
|
||||
dec Inspect.236;
|
||||
let Inspect.347 : Str = ": ";
|
||||
let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
|
||||
dec Inspect.347;
|
||||
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
|
||||
let Inspect.338 : {} = Struct {};
|
||||
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
|
||||
dec Inspect.337;
|
||||
ret Inspect.336;
|
||||
in
|
||||
if Inspect.235 then
|
||||
let Inspect.350 : Str = ", ";
|
||||
let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
|
||||
dec Inspect.350;
|
||||
jump Inspect.349 Inspect.348;
|
||||
else
|
||||
jump Inspect.349 Inspect.234;
|
||||
|
||||
procedure Inspect.233 (Inspect.334, Inspect.335):
|
||||
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
|
||||
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
|
||||
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
|
||||
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
|
||||
joinpoint Inspect.389 Inspect.238:
|
||||
let Inspect.386 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
|
||||
dec Inspect.236;
|
||||
let Inspect.387 : Str = ": ";
|
||||
let Inspect.381 : Str = CallByName Inspect.63 Inspect.386 Inspect.387;
|
||||
dec Inspect.387;
|
||||
let Inspect.377 : Str = CallByName Inspect.239 Inspect.381 Inspect.237;
|
||||
dec Inspect.237;
|
||||
let Inspect.378 : {} = Struct {};
|
||||
let Inspect.376 : {Str, Int1} = CallByName Inspect.241 Inspect.377;
|
||||
dec Inspect.377;
|
||||
ret Inspect.376;
|
||||
in
|
||||
if Inspect.235 then
|
||||
let Inspect.390 : Str = ", ";
|
||||
let Inspect.388 : Str = CallByName Inspect.63 Inspect.234 Inspect.390;
|
||||
dec Inspect.390;
|
||||
jump Inspect.389 Inspect.388;
|
||||
else
|
||||
jump Inspect.389 Inspect.234;
|
||||
|
||||
procedure Inspect.239 (Inspect.240, Inspect.237):
|
||||
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
|
||||
ret Inspect.344;
|
||||
|
||||
procedure Inspect.239 (Inspect.240, Inspect.237):
|
||||
let Inspect.384 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
|
||||
ret Inspect.384;
|
||||
|
||||
procedure Inspect.241 (Inspect.242):
|
||||
let Inspect.380 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.242;
|
||||
let Inspect.379 : {Str, Int1} = Struct {Inspect.242, Inspect.380};
|
||||
ret Inspect.379;
|
||||
|
||||
procedure Inspect.243 (Inspect.326):
|
||||
let Inspect.367 : Str = StructAtIndex 0 Inspect.326;
|
||||
ret Inspect.367;
|
||||
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.401 : Str = "\"";
|
||||
let Inspect.400 : Str = CallByName Inspect.63 Inspect.251 Inspect.401;
|
||||
dec Inspect.401;
|
||||
let Inspect.398 : Str = CallByName Inspect.63 Inspect.400 Inspect.249;
|
||||
let Inspect.399 : Str = "\"";
|
||||
let Inspect.397 : Str = CallByName Inspect.63 Inspect.398 Inspect.399;
|
||||
dec Inspect.399;
|
||||
ret Inspect.397;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.345 : Str = CallByName #Derived.6 Inspect.149 Inspect.303;
|
||||
ret Inspect.345;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.354 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
|
||||
ret Inspect.354;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.385 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
|
||||
ret Inspect.385;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.45 (Inspect.228):
|
||||
let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.45 (Inspect.228):
|
||||
let Inspect.355 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
|
||||
ret Inspect.355;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.393 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.393;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.363 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.363;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.638 : U64 = 0i64;
|
||||
let List.639 : U64 = CallByName List.6 List.166;
|
||||
let List.637 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.638 List.639;
|
||||
ret List.637;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.645 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.645;
|
||||
let List.648 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.648;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.644 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.644;
|
||||
let List.647 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.647;
|
||||
|
||||
procedure List.92 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
|
||||
joinpoint List.637 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.639 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.639 then
|
||||
let List.643 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.643;
|
||||
let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.643;
|
||||
let List.642 : U64 = 1i64;
|
||||
let List.641 : U64 = CallByName Num.51 List.169 List.642;
|
||||
jump List.637 List.166 List.171 List.168 List.641 List.170;
|
||||
procedure List.95 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
|
||||
joinpoint List.640 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.642 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.642 then
|
||||
let List.646 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.646;
|
||||
let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.646;
|
||||
let List.645 : U64 = 1i64;
|
||||
let List.644 : U64 = CallByName Num.51 List.172 List.645;
|
||||
jump List.640 List.169 List.174 List.171 List.644 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.26;
|
||||
jump List.637 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
|
||||
inc #Derived_gen.22;
|
||||
jump List.640 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
|
||||
|
||||
procedure List.92 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.39;
|
||||
jump List.625 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43;
|
||||
inc #Derived_gen.43;
|
||||
jump List.628 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.233 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.233;
|
||||
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.237;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.4 : Str = "bar";
|
||||
|
@ -4,15 +4,15 @@ procedure #Derived.0 (#Derived.1):
|
||||
|
||||
procedure #Derived.2 (#Derived.3, #Derived.1):
|
||||
let #Derived_gen.13 : I64 = StructAtIndex 1 #Derived.1;
|
||||
let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.53 #Derived_gen.13;
|
||||
let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.57 #Derived_gen.13;
|
||||
let #Derived_gen.12 : Str = "a";
|
||||
let #Derived_gen.6 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.11, #Derived_gen.12};
|
||||
let #Derived_gen.10 : Decimal = StructAtIndex 0 #Derived.1;
|
||||
let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.58 #Derived_gen.10;
|
||||
let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.62 #Derived_gen.10;
|
||||
let #Derived_gen.9 : Str = "b";
|
||||
let #Derived_gen.7 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.8, #Derived_gen.9};
|
||||
let #Derived_gen.5 : List {[C I64, C Decimal], Str} = Array [#Derived_gen.6, #Derived_gen.7];
|
||||
let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.41 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.45 #Derived_gen.5;
|
||||
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
@ -25,192 +25,192 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.225 (Inspect.226, Inspect.224):
|
||||
let Inspect.349 : Str = "{";
|
||||
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.349;
|
||||
dec Inspect.349;
|
||||
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
|
||||
dec Inspect.324;
|
||||
let Inspect.321 : {} = Struct {};
|
||||
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
|
||||
let Inspect.317 : Str = "}";
|
||||
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
|
||||
dec Inspect.317;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.227 (Inspect.228, Inspect.224):
|
||||
let Inspect.348 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.228;
|
||||
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.348};
|
||||
let Inspect.329 : {} = Struct {};
|
||||
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.229 (Inspect.330, Inspect.331):
|
||||
let Inspect.233 : [C I64, C Decimal] = StructAtIndex 0 Inspect.331;
|
||||
let Inspect.232 : Str = StructAtIndex 1 Inspect.331;
|
||||
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
|
||||
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
|
||||
joinpoint Inspect.346 Inspect.234:
|
||||
let Inspect.343 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
|
||||
dec Inspect.232;
|
||||
let Inspect.344 : Str = ": ";
|
||||
let Inspect.337 : Str = CallByName Inspect.59 Inspect.343 Inspect.344;
|
||||
dec Inspect.344;
|
||||
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
|
||||
let Inspect.334 : {} = Struct {};
|
||||
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
|
||||
dec Inspect.333;
|
||||
ret Inspect.332;
|
||||
in
|
||||
if Inspect.231 then
|
||||
let Inspect.347 : Str = ", ";
|
||||
let Inspect.345 : Str = CallByName Inspect.59 Inspect.230 Inspect.347;
|
||||
dec Inspect.347;
|
||||
jump Inspect.346 Inspect.345;
|
||||
else
|
||||
jump Inspect.346 Inspect.230;
|
||||
|
||||
procedure Inspect.235 (Inspect.236, Inspect.233):
|
||||
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
|
||||
ret Inspect.340;
|
||||
|
||||
procedure Inspect.237 (Inspect.238):
|
||||
let Inspect.336 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.238;
|
||||
let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
|
||||
ret Inspect.335;
|
||||
|
||||
procedure Inspect.239 (Inspect.322):
|
||||
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.274 (Inspect.275, #Attr.12):
|
||||
let Inspect.362 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
let Inspect.361 : Str = CallByName Num.96 Inspect.362;
|
||||
let Inspect.360 : Str = CallByName Inspect.59 Inspect.275 Inspect.361;
|
||||
dec Inspect.361;
|
||||
ret Inspect.360;
|
||||
|
||||
procedure Inspect.289 (Inspect.290, #Attr.12):
|
||||
let Inspect.356 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Inspect.355 : Str = CallByName Num.96 Inspect.356;
|
||||
let Inspect.354 : Str = CallByName Inspect.59 Inspect.290 Inspect.355;
|
||||
dec Inspect.355;
|
||||
ret Inspect.354;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.342 : U8 = GetTagId Inspect.299;
|
||||
switch Inspect.342:
|
||||
case 0:
|
||||
let Inspect.341 : Str = CallByName Inspect.274 Inspect.145 Inspect.299;
|
||||
ret Inspect.341;
|
||||
|
||||
default:
|
||||
let Inspect.341 : Str = CallByName Inspect.289 Inspect.145 Inspect.299;
|
||||
ret Inspect.341;
|
||||
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.41 (Inspect.224):
|
||||
let Inspect.311 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.224;
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : {Decimal, I64} = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.53 (Inspect.273):
|
||||
let Inspect.358 : [C I64, C Decimal] = TagId(0) Inspect.273;
|
||||
let Inspect.357 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.358;
|
||||
ret Inspect.357;
|
||||
|
||||
procedure Inspect.58 (Inspect.288):
|
||||
let Inspect.351 : [C I64, C Decimal] = TagId(1) Inspect.288;
|
||||
let Inspect.350 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.351;
|
||||
ret Inspect.350;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.229 (Inspect.230, Inspect.228):
|
||||
let Inspect.353 : Str = "{";
|
||||
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.353;
|
||||
dec Inspect.353;
|
||||
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
|
||||
dec Inspect.328;
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
|
||||
let Inspect.321 : Str = "}";
|
||||
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
|
||||
dec Inspect.321;
|
||||
ret Inspect.319;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.231 (Inspect.232, Inspect.228):
|
||||
let Inspect.352 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.232;
|
||||
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.352};
|
||||
let Inspect.333 : {} = Struct {};
|
||||
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.233 (Inspect.334, Inspect.335):
|
||||
let Inspect.237 : [C I64, C Decimal] = StructAtIndex 0 Inspect.335;
|
||||
let Inspect.236 : Str = StructAtIndex 1 Inspect.335;
|
||||
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
|
||||
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
|
||||
joinpoint Inspect.350 Inspect.238:
|
||||
let Inspect.347 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
|
||||
dec Inspect.236;
|
||||
let Inspect.348 : Str = ": ";
|
||||
let Inspect.341 : Str = CallByName Inspect.63 Inspect.347 Inspect.348;
|
||||
dec Inspect.348;
|
||||
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
|
||||
let Inspect.338 : {} = Struct {};
|
||||
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
|
||||
dec Inspect.337;
|
||||
ret Inspect.336;
|
||||
in
|
||||
if Inspect.235 then
|
||||
let Inspect.351 : Str = ", ";
|
||||
let Inspect.349 : Str = CallByName Inspect.63 Inspect.234 Inspect.351;
|
||||
dec Inspect.351;
|
||||
jump Inspect.350 Inspect.349;
|
||||
else
|
||||
jump Inspect.350 Inspect.234;
|
||||
|
||||
procedure Inspect.239 (Inspect.240, Inspect.237):
|
||||
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
|
||||
ret Inspect.344;
|
||||
|
||||
procedure Inspect.241 (Inspect.242):
|
||||
let Inspect.340 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.242;
|
||||
let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
|
||||
ret Inspect.339;
|
||||
|
||||
procedure Inspect.243 (Inspect.326):
|
||||
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.278 (Inspect.279, #Attr.12):
|
||||
let Inspect.366 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
let Inspect.365 : Str = CallByName Num.96 Inspect.366;
|
||||
let Inspect.364 : Str = CallByName Inspect.63 Inspect.279 Inspect.365;
|
||||
dec Inspect.365;
|
||||
ret Inspect.364;
|
||||
|
||||
procedure Inspect.293 (Inspect.294, #Attr.12):
|
||||
let Inspect.360 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Inspect.359 : Str = CallByName Num.96 Inspect.360;
|
||||
let Inspect.358 : Str = CallByName Inspect.63 Inspect.294 Inspect.359;
|
||||
dec Inspect.359;
|
||||
ret Inspect.358;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.346 : U8 = GetTagId Inspect.303;
|
||||
switch Inspect.346:
|
||||
case 0:
|
||||
let Inspect.345 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
|
||||
ret Inspect.345;
|
||||
|
||||
default:
|
||||
let Inspect.345 : Str = CallByName Inspect.293 Inspect.149 Inspect.303;
|
||||
ret Inspect.345;
|
||||
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.45 (Inspect.228):
|
||||
let Inspect.315 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.228;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : {Decimal, I64} = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.57 (Inspect.277):
|
||||
let Inspect.362 : [C I64, C Decimal] = TagId(0) Inspect.277;
|
||||
let Inspect.361 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.362;
|
||||
ret Inspect.361;
|
||||
|
||||
procedure Inspect.62 (Inspect.292):
|
||||
let Inspect.355 : [C I64, C Decimal] = TagId(1) Inspect.292;
|
||||
let Inspect.354 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.355;
|
||||
ret Inspect.354;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {[C I64, C Decimal], Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {[C I64, C Decimal], Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.26;
|
||||
jump List.625 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
|
||||
jump List.628 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.280 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.280;
|
||||
let Num.282 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : Decimal = 3dec;
|
||||
|
@ -4,10 +4,10 @@ procedure #Derived.0 (#Derived.1):
|
||||
|
||||
procedure #Derived.2 (#Derived.3, #Derived.1):
|
||||
let #Derived_gen.7 : Str = "a";
|
||||
let #Derived_gen.8 : Str = CallByName Inspect.43 #Derived.1;
|
||||
let #Derived_gen.8 : Str = CallByName Inspect.47 #Derived.1;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.5;
|
||||
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
@ -20,167 +20,167 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.225 (Inspect.226, Inspect.224):
|
||||
let Inspect.348 : Str = "{";
|
||||
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
|
||||
dec Inspect.348;
|
||||
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
|
||||
dec Inspect.324;
|
||||
let Inspect.321 : {} = Struct {};
|
||||
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
|
||||
let Inspect.317 : Str = "}";
|
||||
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
|
||||
dec Inspect.317;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.227 (Inspect.228, Inspect.224):
|
||||
let Inspect.347 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.228;
|
||||
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
|
||||
let Inspect.329 : {} = Struct {};
|
||||
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.229 (Inspect.330, Inspect.331):
|
||||
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
|
||||
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
|
||||
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
|
||||
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
|
||||
joinpoint Inspect.345 Inspect.234:
|
||||
let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
|
||||
dec Inspect.232;
|
||||
let Inspect.343 : Str = ": ";
|
||||
let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
|
||||
dec Inspect.343;
|
||||
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
|
||||
dec Inspect.233;
|
||||
let Inspect.334 : {} = Struct {};
|
||||
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
|
||||
dec Inspect.333;
|
||||
ret Inspect.332;
|
||||
in
|
||||
if Inspect.231 then
|
||||
let Inspect.346 : Str = ", ";
|
||||
let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
|
||||
dec Inspect.346;
|
||||
jump Inspect.345 Inspect.344;
|
||||
else
|
||||
jump Inspect.345 Inspect.230;
|
||||
|
||||
procedure Inspect.235 (Inspect.236, Inspect.233):
|
||||
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
|
||||
ret Inspect.340;
|
||||
|
||||
procedure Inspect.237 (Inspect.238):
|
||||
let Inspect.336 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.238;
|
||||
let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
|
||||
ret Inspect.335;
|
||||
|
||||
procedure Inspect.239 (Inspect.322):
|
||||
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
let Inspect.357 : Str = "\"";
|
||||
let Inspect.356 : Str = CallByName Inspect.59 Inspect.247 Inspect.357;
|
||||
dec Inspect.357;
|
||||
let Inspect.354 : Str = CallByName Inspect.59 Inspect.356 Inspect.245;
|
||||
let Inspect.355 : Str = "\"";
|
||||
let Inspect.353 : Str = CallByName Inspect.59 Inspect.354 Inspect.355;
|
||||
dec Inspect.355;
|
||||
ret Inspect.353;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.341 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
|
||||
ret Inspect.341;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.41 (Inspect.224):
|
||||
let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.349 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.349;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.229 (Inspect.230, Inspect.228):
|
||||
let Inspect.352 : Str = "{";
|
||||
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
|
||||
dec Inspect.352;
|
||||
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
|
||||
dec Inspect.328;
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
|
||||
let Inspect.321 : Str = "}";
|
||||
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
|
||||
dec Inspect.321;
|
||||
ret Inspect.319;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.231 (Inspect.232, Inspect.228):
|
||||
let Inspect.351 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.232;
|
||||
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
|
||||
let Inspect.333 : {} = Struct {};
|
||||
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.233 (Inspect.334, Inspect.335):
|
||||
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
|
||||
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
|
||||
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
|
||||
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
|
||||
joinpoint Inspect.349 Inspect.238:
|
||||
let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
|
||||
dec Inspect.236;
|
||||
let Inspect.347 : Str = ": ";
|
||||
let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
|
||||
dec Inspect.347;
|
||||
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
|
||||
dec Inspect.237;
|
||||
let Inspect.338 : {} = Struct {};
|
||||
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
|
||||
dec Inspect.337;
|
||||
ret Inspect.336;
|
||||
in
|
||||
if Inspect.235 then
|
||||
let Inspect.350 : Str = ", ";
|
||||
let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
|
||||
dec Inspect.350;
|
||||
jump Inspect.349 Inspect.348;
|
||||
else
|
||||
jump Inspect.349 Inspect.234;
|
||||
|
||||
procedure Inspect.239 (Inspect.240, Inspect.237):
|
||||
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
|
||||
ret Inspect.344;
|
||||
|
||||
procedure Inspect.241 (Inspect.242):
|
||||
let Inspect.340 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.242;
|
||||
let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
|
||||
ret Inspect.339;
|
||||
|
||||
procedure Inspect.243 (Inspect.326):
|
||||
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.361 : Str = "\"";
|
||||
let Inspect.360 : Str = CallByName Inspect.63 Inspect.251 Inspect.361;
|
||||
dec Inspect.361;
|
||||
let Inspect.358 : Str = CallByName Inspect.63 Inspect.360 Inspect.249;
|
||||
let Inspect.359 : Str = "\"";
|
||||
let Inspect.357 : Str = CallByName Inspect.63 Inspect.358 Inspect.359;
|
||||
dec Inspect.359;
|
||||
ret Inspect.357;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.345 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
|
||||
ret Inspect.345;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.45 (Inspect.228):
|
||||
let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.353 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.353;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.10;
|
||||
jump List.625 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
|
||||
inc #Derived_gen.14;
|
||||
jump List.628 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : Str = "foo";
|
||||
|
@ -6,15 +6,15 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
|
||||
let #Derived_gen.11 : Str = "a";
|
||||
let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1;
|
||||
inc #Derived_gen.13;
|
||||
let #Derived_gen.12 : Str = CallByName Inspect.43 #Derived_gen.13;
|
||||
let #Derived_gen.12 : Str = CallByName Inspect.47 #Derived_gen.13;
|
||||
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12};
|
||||
let #Derived_gen.8 : Str = "b";
|
||||
let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1;
|
||||
dec #Derived_gen.13;
|
||||
let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived_gen.10;
|
||||
let #Derived_gen.9 : Str = CallByName Inspect.47 #Derived_gen.10;
|
||||
let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9};
|
||||
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7];
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
|
||||
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.5;
|
||||
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
|
||||
dec #Derived_gen.4;
|
||||
ret #Derived_gen.3;
|
||||
@ -27,167 +27,167 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.225 (Inspect.226, Inspect.224):
|
||||
let Inspect.348 : Str = "{";
|
||||
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
|
||||
dec Inspect.348;
|
||||
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
|
||||
dec Inspect.324;
|
||||
let Inspect.321 : {} = Struct {};
|
||||
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
|
||||
let Inspect.317 : Str = "}";
|
||||
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
|
||||
dec Inspect.317;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.227 (Inspect.228, Inspect.224):
|
||||
let Inspect.347 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.228;
|
||||
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
|
||||
let Inspect.329 : {} = Struct {};
|
||||
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.229 (Inspect.330, Inspect.331):
|
||||
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
|
||||
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
|
||||
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
|
||||
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
|
||||
joinpoint Inspect.345 Inspect.234:
|
||||
let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
|
||||
dec Inspect.232;
|
||||
let Inspect.343 : Str = ": ";
|
||||
let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
|
||||
dec Inspect.343;
|
||||
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
|
||||
dec Inspect.233;
|
||||
let Inspect.334 : {} = Struct {};
|
||||
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
|
||||
dec Inspect.333;
|
||||
ret Inspect.332;
|
||||
in
|
||||
if Inspect.231 then
|
||||
let Inspect.346 : Str = ", ";
|
||||
let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
|
||||
dec Inspect.346;
|
||||
jump Inspect.345 Inspect.344;
|
||||
else
|
||||
jump Inspect.345 Inspect.230;
|
||||
|
||||
procedure Inspect.235 (Inspect.236, Inspect.233):
|
||||
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
|
||||
ret Inspect.340;
|
||||
|
||||
procedure Inspect.237 (Inspect.238):
|
||||
let Inspect.336 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.238;
|
||||
let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
|
||||
ret Inspect.335;
|
||||
|
||||
procedure Inspect.239 (Inspect.322):
|
||||
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
let Inspect.357 : Str = "\"";
|
||||
let Inspect.356 : Str = CallByName Inspect.59 Inspect.247 Inspect.357;
|
||||
dec Inspect.357;
|
||||
let Inspect.354 : Str = CallByName Inspect.59 Inspect.356 Inspect.245;
|
||||
let Inspect.355 : Str = "\"";
|
||||
let Inspect.353 : Str = CallByName Inspect.59 Inspect.354 Inspect.355;
|
||||
dec Inspect.355;
|
||||
ret Inspect.353;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.341 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
|
||||
ret Inspect.341;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.41 (Inspect.224):
|
||||
let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.358 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.358;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : {Str, Str} = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.229 (Inspect.230, Inspect.228):
|
||||
let Inspect.352 : Str = "{";
|
||||
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
|
||||
dec Inspect.352;
|
||||
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
|
||||
dec Inspect.328;
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
|
||||
let Inspect.321 : Str = "}";
|
||||
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
|
||||
dec Inspect.321;
|
||||
ret Inspect.319;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.231 (Inspect.232, Inspect.228):
|
||||
let Inspect.351 : Int1 = CallByName Bool.1;
|
||||
inc Inspect.232;
|
||||
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
|
||||
let Inspect.333 : {} = Struct {};
|
||||
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.233 (Inspect.334, Inspect.335):
|
||||
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
|
||||
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
|
||||
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
|
||||
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
|
||||
joinpoint Inspect.349 Inspect.238:
|
||||
let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
|
||||
dec Inspect.236;
|
||||
let Inspect.347 : Str = ": ";
|
||||
let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
|
||||
dec Inspect.347;
|
||||
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
|
||||
dec Inspect.237;
|
||||
let Inspect.338 : {} = Struct {};
|
||||
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
|
||||
dec Inspect.337;
|
||||
ret Inspect.336;
|
||||
in
|
||||
if Inspect.235 then
|
||||
let Inspect.350 : Str = ", ";
|
||||
let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
|
||||
dec Inspect.350;
|
||||
jump Inspect.349 Inspect.348;
|
||||
else
|
||||
jump Inspect.349 Inspect.234;
|
||||
|
||||
procedure Inspect.239 (Inspect.240, Inspect.237):
|
||||
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
|
||||
ret Inspect.344;
|
||||
|
||||
procedure Inspect.241 (Inspect.242):
|
||||
let Inspect.340 : Int1 = CallByName Bool.2;
|
||||
inc Inspect.242;
|
||||
let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
|
||||
ret Inspect.339;
|
||||
|
||||
procedure Inspect.243 (Inspect.326):
|
||||
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
|
||||
ret Inspect.327;
|
||||
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.361 : Str = "\"";
|
||||
let Inspect.360 : Str = CallByName Inspect.63 Inspect.251 Inspect.361;
|
||||
dec Inspect.361;
|
||||
let Inspect.358 : Str = CallByName Inspect.63 Inspect.360 Inspect.249;
|
||||
let Inspect.359 : Str = "\"";
|
||||
let Inspect.357 : Str = CallByName Inspect.63 Inspect.358 Inspect.359;
|
||||
dec Inspect.359;
|
||||
ret Inspect.357;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.345 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
|
||||
ret Inspect.345;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.45 (Inspect.228):
|
||||
let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
|
||||
ret Inspect.315;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.362 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.362;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.323;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.14;
|
||||
jump List.625 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
|
||||
inc #Derived_gen.18;
|
||||
jump List.628 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : Str = "foo";
|
||||
|
@ -1,47 +1,47 @@
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.323 : Str = "\"";
|
||||
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
|
||||
dec Inspect.323;
|
||||
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
|
||||
let Inspect.319 : Str = "\"";
|
||||
let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
|
||||
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
|
||||
dec Inspect.319;
|
||||
let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
|
||||
let Inspect.315 : Str = "\"";
|
||||
let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
|
||||
dec Inspect.315;
|
||||
ret Inspect.313;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.309;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
|
||||
dec Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
ret Inspect.317;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.313;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
|
||||
dec Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.321;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : Str = "abc";
|
||||
|
@ -8,9 +8,9 @@ procedure #Derived.3 (#Derived.4, #Derived.1):
|
||||
ret #Derived_gen.3;
|
||||
in
|
||||
let #Derived_gen.7 : Str = "A";
|
||||
let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived.1;
|
||||
let #Derived_gen.9 : Str = CallByName Inspect.47 #Derived.1;
|
||||
let #Derived_gen.8 : List Str = Array [#Derived_gen.9];
|
||||
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.39 #Derived_gen.7 #Derived_gen.8;
|
||||
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.43 #Derived_gen.7 #Derived_gen.8;
|
||||
dec #Derived_gen.8;
|
||||
dec #Derived_gen.7;
|
||||
jump #Derived_gen.5 #Derived_gen.6;
|
||||
@ -19,168 +19,168 @@ procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.200 (Inspect.201, #Attr.12):
|
||||
let Inspect.342 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
let Inspect.341 : Str = CallByName Inspect.59 Inspect.201 Inspect.342;
|
||||
dec Inspect.342;
|
||||
ret Inspect.341;
|
||||
procedure Inspect.204 (Inspect.205, #Attr.12):
|
||||
let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
let Inspect.345 : Str = CallByName Inspect.63 Inspect.205 Inspect.346;
|
||||
dec Inspect.346;
|
||||
ret Inspect.345;
|
||||
|
||||
procedure Inspect.202 (Inspect.203, #Attr.12):
|
||||
let Inspect.336 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
|
||||
let Inspect.335 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Inspect.334 : Str = "(";
|
||||
let Inspect.333 : Str = CallByName Inspect.59 Inspect.203 Inspect.334;
|
||||
dec Inspect.334;
|
||||
let Inspect.321 : Str = CallByName Inspect.59 Inspect.333 Inspect.335;
|
||||
dec Inspect.335;
|
||||
let Inspect.317 : Str = CallByName Inspect.204 Inspect.321 Inspect.336;
|
||||
dec Inspect.336;
|
||||
let Inspect.318 : Str = ")";
|
||||
let Inspect.316 : Str = CallByName Inspect.59 Inspect.317 Inspect.318;
|
||||
dec Inspect.318;
|
||||
ret Inspect.316;
|
||||
|
||||
procedure Inspect.204 (Inspect.205, Inspect.199):
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.324 : Str = CallByName List.18 Inspect.199 Inspect.205 Inspect.325;
|
||||
ret Inspect.324;
|
||||
|
||||
procedure Inspect.206 (Inspect.207, Inspect.208):
|
||||
let Inspect.332 : Str = " ";
|
||||
let Inspect.327 : Str = CallByName Inspect.59 Inspect.207 Inspect.332;
|
||||
dec Inspect.332;
|
||||
let Inspect.326 : Str = CallByName Inspect.209 Inspect.327 Inspect.208;
|
||||
ret Inspect.326;
|
||||
|
||||
procedure Inspect.209 (Inspect.210, Inspect.208):
|
||||
let Inspect.330 : Str = CallByName Inspect.31 Inspect.208 Inspect.210;
|
||||
ret Inspect.330;
|
||||
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
let Inspect.351 : Str = "\"";
|
||||
let Inspect.350 : Str = CallByName Inspect.59 Inspect.247 Inspect.351;
|
||||
dec Inspect.351;
|
||||
let Inspect.348 : Str = CallByName Inspect.59 Inspect.350 Inspect.245;
|
||||
let Inspect.349 : Str = "\"";
|
||||
let Inspect.347 : Str = CallByName Inspect.59 Inspect.348 Inspect.349;
|
||||
dec Inspect.349;
|
||||
ret Inspect.347;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.311 : U8 = GetTagId Inspect.299;
|
||||
switch Inspect.311:
|
||||
case 0:
|
||||
let Inspect.310 : Str = CallByName Inspect.200 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
default:
|
||||
let Inspect.310 : Str = CallByName Inspect.202 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.331 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.39 (Inspect.198, Inspect.199):
|
||||
let Inspect.337 : Int1 = CallByName List.1 Inspect.199;
|
||||
if Inspect.337 then
|
||||
inc Inspect.198;
|
||||
let Inspect.339 : [C Str, C Str List Str] = TagId(0) Inspect.198;
|
||||
let Inspect.338 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.339;
|
||||
ret Inspect.338;
|
||||
else
|
||||
inc Inspect.199;
|
||||
inc Inspect.198;
|
||||
let Inspect.313 : [C Str, C Str List Str] = TagId(1) Inspect.198 Inspect.199;
|
||||
let Inspect.312 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.313;
|
||||
ret Inspect.312;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.343 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.343;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.3 Inspect.304 Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.320 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.206 (Inspect.207, #Attr.12):
|
||||
let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
|
||||
let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Inspect.338 : Str = "(";
|
||||
let Inspect.337 : Str = CallByName Inspect.63 Inspect.207 Inspect.338;
|
||||
dec Inspect.338;
|
||||
let Inspect.325 : Str = CallByName Inspect.63 Inspect.337 Inspect.339;
|
||||
dec Inspect.339;
|
||||
let Inspect.321 : Str = CallByName Inspect.208 Inspect.325 Inspect.340;
|
||||
dec Inspect.340;
|
||||
let Inspect.322 : Str = ")";
|
||||
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
|
||||
dec Inspect.322;
|
||||
ret Inspect.320;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.208 (Inspect.209, Inspect.203):
|
||||
let Inspect.329 : {} = Struct {};
|
||||
let Inspect.328 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.329;
|
||||
ret Inspect.328;
|
||||
|
||||
procedure List.1 (List.110):
|
||||
let List.635 : U64 = CallByName List.6 List.110;
|
||||
let List.636 : U64 = 0i64;
|
||||
let List.634 : Int1 = CallByName Bool.11 List.635 List.636;
|
||||
ret List.634;
|
||||
procedure Inspect.210 (Inspect.211, Inspect.212):
|
||||
let Inspect.336 : Str = " ";
|
||||
let Inspect.331 : Str = CallByName Inspect.63 Inspect.211 Inspect.336;
|
||||
dec Inspect.336;
|
||||
let Inspect.330 : Str = CallByName Inspect.213 Inspect.331 Inspect.212;
|
||||
ret Inspect.330;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : Str = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.213 (Inspect.214, Inspect.212):
|
||||
let Inspect.334 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
|
||||
ret Inspect.334;
|
||||
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.355 : Str = "\"";
|
||||
let Inspect.354 : Str = CallByName Inspect.63 Inspect.251 Inspect.355;
|
||||
dec Inspect.355;
|
||||
let Inspect.352 : Str = CallByName Inspect.63 Inspect.354 Inspect.249;
|
||||
let Inspect.353 : Str = "\"";
|
||||
let Inspect.351 : Str = CallByName Inspect.63 Inspect.352 Inspect.353;
|
||||
dec Inspect.353;
|
||||
ret Inspect.351;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.315 : U8 = GetTagId Inspect.303;
|
||||
switch Inspect.315:
|
||||
case 0:
|
||||
let Inspect.314 : Str = CallByName Inspect.204 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
default:
|
||||
let Inspect.314 : Str = CallByName Inspect.206 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.335 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
|
||||
ret Inspect.335;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.43 (Inspect.202, Inspect.203):
|
||||
let Inspect.341 : Int1 = CallByName List.1 Inspect.203;
|
||||
if Inspect.341 then
|
||||
inc Inspect.202;
|
||||
let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.202;
|
||||
let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343;
|
||||
ret Inspect.342;
|
||||
else
|
||||
inc Inspect.203;
|
||||
inc Inspect.202;
|
||||
let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
|
||||
let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317;
|
||||
ret Inspect.316;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.347 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.347;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.3 Inspect.308 Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.324 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.324;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.1 (List.113):
|
||||
let List.638 : U64 = CallByName List.6 List.113;
|
||||
let List.639 : U64 = 0i64;
|
||||
let List.637 : Int1 = CallByName Bool.11 List.638 List.639;
|
||||
ret List.637;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : Str = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : Str = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : Str = CallByName Inspect.206 List.167 List.631;
|
||||
dec List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : Str = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : Str = CallByName Inspect.210 List.170 List.634;
|
||||
dec List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.10;
|
||||
jump List.625 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
|
||||
inc #Derived_gen.14;
|
||||
jump List.628 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.4 : Str = "foo";
|
||||
|
@ -10,10 +10,10 @@ procedure #Derived.4 (#Derived.5, #Derived.1):
|
||||
let #Derived.2 : Str = StructAtIndex 0 #Derived.1;
|
||||
let #Derived.3 : Str = StructAtIndex 1 #Derived.1;
|
||||
let #Derived_gen.7 : Str = "A";
|
||||
let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived.2;
|
||||
let #Derived_gen.10 : Str = CallByName Inspect.43 #Derived.3;
|
||||
let #Derived_gen.9 : Str = CallByName Inspect.47 #Derived.2;
|
||||
let #Derived_gen.10 : Str = CallByName Inspect.47 #Derived.3;
|
||||
let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10];
|
||||
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.39 #Derived_gen.7 #Derived_gen.8;
|
||||
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.43 #Derived_gen.7 #Derived_gen.8;
|
||||
dec #Derived_gen.8;
|
||||
dec #Derived_gen.7;
|
||||
jump #Derived_gen.5 #Derived_gen.6;
|
||||
@ -22,168 +22,168 @@ procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
ret Bool.23;
|
||||
|
||||
procedure Inspect.200 (Inspect.201, #Attr.12):
|
||||
let Inspect.342 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
let Inspect.341 : Str = CallByName Inspect.59 Inspect.201 Inspect.342;
|
||||
dec Inspect.342;
|
||||
ret Inspect.341;
|
||||
procedure Inspect.204 (Inspect.205, #Attr.12):
|
||||
let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
let Inspect.345 : Str = CallByName Inspect.63 Inspect.205 Inspect.346;
|
||||
dec Inspect.346;
|
||||
ret Inspect.345;
|
||||
|
||||
procedure Inspect.202 (Inspect.203, #Attr.12):
|
||||
let Inspect.336 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
|
||||
let Inspect.335 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Inspect.334 : Str = "(";
|
||||
let Inspect.333 : Str = CallByName Inspect.59 Inspect.203 Inspect.334;
|
||||
dec Inspect.334;
|
||||
let Inspect.321 : Str = CallByName Inspect.59 Inspect.333 Inspect.335;
|
||||
dec Inspect.335;
|
||||
let Inspect.317 : Str = CallByName Inspect.204 Inspect.321 Inspect.336;
|
||||
dec Inspect.336;
|
||||
let Inspect.318 : Str = ")";
|
||||
let Inspect.316 : Str = CallByName Inspect.59 Inspect.317 Inspect.318;
|
||||
dec Inspect.318;
|
||||
ret Inspect.316;
|
||||
|
||||
procedure Inspect.204 (Inspect.205, Inspect.199):
|
||||
let Inspect.325 : {} = Struct {};
|
||||
let Inspect.324 : Str = CallByName List.18 Inspect.199 Inspect.205 Inspect.325;
|
||||
ret Inspect.324;
|
||||
|
||||
procedure Inspect.206 (Inspect.207, Inspect.208):
|
||||
let Inspect.332 : Str = " ";
|
||||
let Inspect.327 : Str = CallByName Inspect.59 Inspect.207 Inspect.332;
|
||||
dec Inspect.332;
|
||||
let Inspect.326 : Str = CallByName Inspect.209 Inspect.327 Inspect.208;
|
||||
ret Inspect.326;
|
||||
|
||||
procedure Inspect.209 (Inspect.210, Inspect.208):
|
||||
let Inspect.330 : Str = CallByName Inspect.31 Inspect.208 Inspect.210;
|
||||
ret Inspect.330;
|
||||
|
||||
procedure Inspect.246 (Inspect.247, Inspect.245):
|
||||
let Inspect.351 : Str = "\"";
|
||||
let Inspect.350 : Str = CallByName Inspect.59 Inspect.247 Inspect.351;
|
||||
dec Inspect.351;
|
||||
let Inspect.348 : Str = CallByName Inspect.59 Inspect.350 Inspect.245;
|
||||
let Inspect.349 : Str = "\"";
|
||||
let Inspect.347 : Str = CallByName Inspect.59 Inspect.348 Inspect.349;
|
||||
dec Inspect.349;
|
||||
ret Inspect.347;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.30 (Inspect.143):
|
||||
ret Inspect.143;
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.311 : U8 = GetTagId Inspect.299;
|
||||
switch Inspect.311:
|
||||
case 0:
|
||||
let Inspect.310 : Str = CallByName Inspect.200 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
default:
|
||||
let Inspect.310 : Str = CallByName Inspect.202 Inspect.145 Inspect.299;
|
||||
ret Inspect.310;
|
||||
|
||||
|
||||
procedure Inspect.31 (Inspect.299, Inspect.145):
|
||||
let Inspect.331 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
|
||||
ret Inspect.331;
|
||||
|
||||
procedure Inspect.33 (Inspect.148):
|
||||
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
|
||||
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
|
||||
ret Inspect.300;
|
||||
|
||||
procedure Inspect.35 (Inspect.297):
|
||||
let Inspect.307 : Str = "";
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.39 (Inspect.198, Inspect.199):
|
||||
let Inspect.337 : Int1 = CallByName List.1 Inspect.199;
|
||||
if Inspect.337 then
|
||||
inc Inspect.198;
|
||||
let Inspect.339 : [C Str, C Str List Str] = TagId(0) Inspect.198;
|
||||
let Inspect.338 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.339;
|
||||
ret Inspect.338;
|
||||
else
|
||||
inc Inspect.199;
|
||||
inc Inspect.198;
|
||||
let Inspect.313 : [C Str, C Str List Str] = TagId(1) Inspect.198 Inspect.199;
|
||||
let Inspect.312 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.313;
|
||||
ret Inspect.312;
|
||||
|
||||
procedure Inspect.43 (Inspect.245):
|
||||
let Inspect.352 : Str = CallByName Inspect.30 Inspect.245;
|
||||
ret Inspect.352;
|
||||
|
||||
procedure Inspect.5 (Inspect.146):
|
||||
let Inspect.308 : {Str, Str} = CallByName #Derived.0 Inspect.146;
|
||||
let Inspect.305 : {} = Struct {};
|
||||
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
|
||||
let Inspect.303 : Str = CallByName #Derived.4 Inspect.304 Inspect.308;
|
||||
ret Inspect.303;
|
||||
|
||||
procedure Inspect.59 (Inspect.296, Inspect.292):
|
||||
let Inspect.320 : Str = CallByName Str.3 Inspect.296 Inspect.292;
|
||||
procedure Inspect.206 (Inspect.207, #Attr.12):
|
||||
let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
|
||||
let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Inspect.338 : Str = "(";
|
||||
let Inspect.337 : Str = CallByName Inspect.63 Inspect.207 Inspect.338;
|
||||
dec Inspect.338;
|
||||
let Inspect.325 : Str = CallByName Inspect.63 Inspect.337 Inspect.339;
|
||||
dec Inspect.339;
|
||||
let Inspect.321 : Str = CallByName Inspect.208 Inspect.325 Inspect.340;
|
||||
dec Inspect.340;
|
||||
let Inspect.322 : Str = ")";
|
||||
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
|
||||
dec Inspect.322;
|
||||
ret Inspect.320;
|
||||
|
||||
procedure Inspect.60 (Inspect.298):
|
||||
ret Inspect.298;
|
||||
procedure Inspect.208 (Inspect.209, Inspect.203):
|
||||
let Inspect.329 : {} = Struct {};
|
||||
let Inspect.328 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.329;
|
||||
ret Inspect.328;
|
||||
|
||||
procedure List.1 (List.110):
|
||||
let List.635 : U64 = CallByName List.6 List.110;
|
||||
let List.636 : U64 = 0i64;
|
||||
let List.634 : Int1 = CallByName Bool.11 List.635 List.636;
|
||||
ret List.634;
|
||||
procedure Inspect.210 (Inspect.211, Inspect.212):
|
||||
let Inspect.336 : Str = " ";
|
||||
let Inspect.331 : Str = CallByName Inspect.63 Inspect.211 Inspect.336;
|
||||
dec Inspect.336;
|
||||
let Inspect.330 : Str = CallByName Inspect.213 Inspect.331 Inspect.212;
|
||||
ret Inspect.330;
|
||||
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : Str = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure Inspect.213 (Inspect.214, Inspect.212):
|
||||
let Inspect.334 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
|
||||
ret Inspect.334;
|
||||
|
||||
procedure Inspect.250 (Inspect.251, Inspect.249):
|
||||
let Inspect.355 : Str = "\"";
|
||||
let Inspect.354 : Str = CallByName Inspect.63 Inspect.251 Inspect.355;
|
||||
dec Inspect.355;
|
||||
let Inspect.352 : Str = CallByName Inspect.63 Inspect.354 Inspect.249;
|
||||
let Inspect.353 : Str = "\"";
|
||||
let Inspect.351 : Str = CallByName Inspect.63 Inspect.352 Inspect.353;
|
||||
dec Inspect.353;
|
||||
ret Inspect.351;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.30 (Inspect.147):
|
||||
ret Inspect.147;
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.315 : U8 = GetTagId Inspect.303;
|
||||
switch Inspect.315:
|
||||
case 0:
|
||||
let Inspect.314 : Str = CallByName Inspect.204 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
default:
|
||||
let Inspect.314 : Str = CallByName Inspect.206 Inspect.149 Inspect.303;
|
||||
ret Inspect.314;
|
||||
|
||||
|
||||
procedure Inspect.31 (Inspect.303, Inspect.149):
|
||||
let Inspect.335 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
|
||||
ret Inspect.335;
|
||||
|
||||
procedure Inspect.33 (Inspect.152):
|
||||
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
|
||||
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
|
||||
ret Inspect.304;
|
||||
|
||||
procedure Inspect.39 (Inspect.301):
|
||||
let Inspect.311 : Str = "";
|
||||
ret Inspect.311;
|
||||
|
||||
procedure Inspect.43 (Inspect.202, Inspect.203):
|
||||
let Inspect.341 : Int1 = CallByName List.1 Inspect.203;
|
||||
if Inspect.341 then
|
||||
inc Inspect.202;
|
||||
let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.202;
|
||||
let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343;
|
||||
ret Inspect.342;
|
||||
else
|
||||
inc Inspect.203;
|
||||
inc Inspect.202;
|
||||
let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
|
||||
let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317;
|
||||
ret Inspect.316;
|
||||
|
||||
procedure Inspect.47 (Inspect.249):
|
||||
let Inspect.356 : Str = CallByName Inspect.30 Inspect.249;
|
||||
ret Inspect.356;
|
||||
|
||||
procedure Inspect.5 (Inspect.150):
|
||||
let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150;
|
||||
let Inspect.309 : {} = Struct {};
|
||||
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
|
||||
let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312;
|
||||
ret Inspect.307;
|
||||
|
||||
procedure Inspect.63 (Inspect.300, Inspect.296):
|
||||
let Inspect.324 : Str = CallByName Str.3 Inspect.300 Inspect.296;
|
||||
ret Inspect.324;
|
||||
|
||||
procedure Inspect.64 (Inspect.302):
|
||||
ret Inspect.302;
|
||||
|
||||
procedure List.1 (List.113):
|
||||
let List.638 : U64 = CallByName List.6 List.113;
|
||||
let List.639 : U64 = 0i64;
|
||||
let List.637 : Int1 = CallByName Bool.11 List.638 List.639;
|
||||
ret List.637;
|
||||
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : Str = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : Str = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : Str = CallByName Inspect.206 List.167 List.631;
|
||||
dec List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : Str = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : Str = CallByName Inspect.210 List.170 List.634;
|
||||
dec List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.13;
|
||||
jump List.625 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
|
||||
jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.5 : Str = "foo";
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.622;
|
||||
let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.625;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.1 : List I64 = Array [1i64, 2i64];
|
||||
|
4
crates/compiler/test_mono/generated/ir_plus.txt
generated
4
crates/compiler/test_mono/generated/ir_plus.txt
generated
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : I64 = 1i64;
|
||||
|
4
crates/compiler/test_mono/generated/ir_round.txt
generated
4
crates/compiler/test_mono/generated/ir_round.txt
generated
@ -1,6 +1,6 @@
|
||||
procedure Num.45 (#Attr.2):
|
||||
let Num.279 : I64 = lowlevel NumRound #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumRound #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : Decimal = 3.6dec;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.1 : I64 = 3i64;
|
||||
|
28
crates/compiler/test_mono/generated/ir_when_idiv.txt
generated
28
crates/compiler/test_mono/generated/ir_when_idiv.txt
generated
@ -1,22 +1,22 @@
|
||||
procedure Num.157 (#Attr.2, #Attr.3):
|
||||
let Num.281 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.30 (#Attr.2):
|
||||
let Num.286 : I64 = 0i64;
|
||||
let Num.285 : Int1 = lowlevel Eq #Attr.2 Num.286;
|
||||
ret Num.285;
|
||||
let Num.288 : I64 = 0i64;
|
||||
let Num.287 : Int1 = lowlevel Eq #Attr.2 Num.288;
|
||||
ret Num.287;
|
||||
|
||||
procedure Num.40 (Num.247, Num.248):
|
||||
let Num.282 : Int1 = CallByName Num.30 Num.248;
|
||||
if Num.282 then
|
||||
let Num.284 : {} = Struct {};
|
||||
let Num.283 : [C {}, C I64] = TagId(0) Num.284;
|
||||
ret Num.283;
|
||||
procedure Num.40 (Num.249, Num.250):
|
||||
let Num.284 : Int1 = CallByName Num.30 Num.250;
|
||||
if Num.284 then
|
||||
let Num.286 : {} = Struct {};
|
||||
let Num.285 : [C {}, C I64] = TagId(0) Num.286;
|
||||
ret Num.285;
|
||||
else
|
||||
let Num.280 : I64 = CallByName Num.157 Num.247 Num.248;
|
||||
let Num.279 : [C {}, C I64] = TagId(1) Num.280;
|
||||
ret Num.279;
|
||||
let Num.282 : I64 = CallByName Num.157 Num.249 Num.250;
|
||||
let Num.281 : [C {}, C I64] = TagId(1) Num.282;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.8 : I64 = 1000i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.10 : I64 = 41i64;
|
||||
|
@ -6,66 +6,66 @@ procedure Bool.2 ():
|
||||
let Bool.23 : Int1 = true;
|
||||
ret Bool.23;
|
||||
|
||||
procedure List.2 (List.111, List.112):
|
||||
let List.636 : U64 = CallByName List.6 List.111;
|
||||
let List.632 : Int1 = CallByName Num.22 List.112 List.636;
|
||||
if List.632 then
|
||||
let List.634 : I64 = CallByName List.66 List.111 List.112;
|
||||
let List.633 : [C {}, C I64] = TagId(1) List.634;
|
||||
ret List.633;
|
||||
procedure List.2 (List.114, List.115):
|
||||
let List.639 : U64 = CallByName List.6 List.114;
|
||||
let List.635 : Int1 = CallByName Num.22 List.115 List.639;
|
||||
if List.635 then
|
||||
let List.637 : I64 = CallByName List.66 List.114 List.115;
|
||||
let List.636 : [C {}, C I64] = TagId(1) List.637;
|
||||
ret List.636;
|
||||
else
|
||||
let List.631 : {} = Struct {};
|
||||
let List.630 : [C {}, C I64] = TagId(0) List.631;
|
||||
ret List.630;
|
||||
let List.634 : {} = Struct {};
|
||||
let List.633 : [C {}, C I64] = TagId(0) List.634;
|
||||
ret List.633;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.637 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.637;
|
||||
let List.640 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.640;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.635 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
let List.638 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
|
||||
procedure List.9 (List.383):
|
||||
let List.629 : U64 = 0i64;
|
||||
let List.622 : [C {}, C I64] = CallByName List.2 List.383 List.629;
|
||||
let List.626 : U8 = 1i64;
|
||||
let List.627 : U8 = GetTagId List.622;
|
||||
let List.628 : Int1 = lowlevel Eq List.626 List.627;
|
||||
if List.628 then
|
||||
let List.384 : I64 = UnionAtIndex (Id 1) (Index 0) List.622;
|
||||
let List.623 : [C Int1, C I64] = TagId(1) List.384;
|
||||
ret List.623;
|
||||
procedure List.9 (List.386):
|
||||
let List.632 : U64 = 0i64;
|
||||
let List.625 : [C {}, C I64] = CallByName List.2 List.386 List.632;
|
||||
let List.629 : U8 = 1i64;
|
||||
let List.630 : U8 = GetTagId List.625;
|
||||
let List.631 : Int1 = lowlevel Eq List.629 List.630;
|
||||
if List.631 then
|
||||
let List.387 : I64 = UnionAtIndex (Id 1) (Index 0) List.625;
|
||||
let List.626 : [C Int1, C I64] = TagId(1) List.387;
|
||||
ret List.626;
|
||||
else
|
||||
let List.625 : Int1 = true;
|
||||
let List.624 : [C Int1, C I64] = TagId(0) List.625;
|
||||
ret List.624;
|
||||
let List.628 : Int1 = true;
|
||||
let List.627 : [C Int1, C I64] = TagId(0) List.628;
|
||||
ret List.627;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Str.27 (Str.78):
|
||||
let Str.232 : [C Int1, C I64] = CallByName Str.60 Str.78;
|
||||
ret Str.232;
|
||||
procedure Str.27 (Str.82):
|
||||
let Str.236 : [C Int1, C I64] = CallByName Str.64 Str.82;
|
||||
ret Str.236;
|
||||
|
||||
procedure Str.42 (#Attr.2):
|
||||
let Str.240 : {I64, U8} = lowlevel StrToNum #Attr.2;
|
||||
ret Str.240;
|
||||
let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
|
||||
ret Str.244;
|
||||
|
||||
procedure Str.60 (Str.185):
|
||||
let Str.186 : {I64, U8} = CallByName Str.42 Str.185;
|
||||
let Str.238 : U8 = StructAtIndex 1 Str.186;
|
||||
let Str.239 : U8 = 0i64;
|
||||
let Str.235 : Int1 = CallByName Bool.11 Str.238 Str.239;
|
||||
if Str.235 then
|
||||
let Str.237 : I64 = StructAtIndex 0 Str.186;
|
||||
let Str.236 : [C Int1, C I64] = TagId(1) Str.237;
|
||||
ret Str.236;
|
||||
procedure Str.64 (Str.189):
|
||||
let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
|
||||
let Str.242 : U8 = StructAtIndex 1 Str.190;
|
||||
let Str.243 : U8 = 0i64;
|
||||
let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
|
||||
if Str.239 then
|
||||
let Str.241 : I64 = StructAtIndex 0 Str.190;
|
||||
let Str.240 : [C Int1, C I64] = TagId(1) Str.241;
|
||||
ret Str.240;
|
||||
else
|
||||
let Str.234 : Int1 = false;
|
||||
let Str.233 : [C Int1, C I64] = TagId(0) Str.234;
|
||||
ret Str.233;
|
||||
let Str.238 : Int1 = false;
|
||||
let Str.237 : [C Int1, C I64] = TagId(0) Str.238;
|
||||
ret Str.237;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : Int1 = CallByName Bool.2;
|
||||
|
238
crates/compiler/test_mono/generated/issue_4770.txt
generated
238
crates/compiler/test_mono/generated/issue_4770.txt
generated
@ -6,137 +6,137 @@ procedure Bool.2 ():
|
||||
let Bool.24 : Int1 = true;
|
||||
ret Bool.24;
|
||||
|
||||
procedure List.107 (List.536, List.537, List.538):
|
||||
let List.636 : U64 = 0i64;
|
||||
let List.637 : U64 = CallByName List.6 List.536;
|
||||
let List.635 : [C {}, C {}] = CallByName List.80 List.536 List.537 List.538 List.636 List.637;
|
||||
ret List.635;
|
||||
|
||||
procedure List.23 (List.278, List.279, List.280):
|
||||
let List.672 : U64 = CallByName List.6 List.278;
|
||||
let List.673 : U64 = CallByName List.6 List.279;
|
||||
let List.281 : U64 = CallByName Num.148 List.672 List.673;
|
||||
let List.658 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.281;
|
||||
let List.659 : U64 = 0i64;
|
||||
let List.657 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.97 List.278 List.279 List.658 List.280 List.659 List.281;
|
||||
ret List.657;
|
||||
|
||||
procedure List.239 (List.624, List.240, List.238):
|
||||
let List.654 : Int1 = CallByName Test.1 List.240;
|
||||
if List.654 then
|
||||
let List.656 : {} = Struct {};
|
||||
let List.655 : [C {}, C {}] = TagId(1) List.656;
|
||||
ret List.655;
|
||||
procedure List.100 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6):
|
||||
joinpoint List.663 List.285 List.286 List.287 List.288 List.289 List.290:
|
||||
let List.665 : Int1 = CallByName Num.22 List.289 List.290;
|
||||
if List.665 then
|
||||
let List.671 : [<r>C I64, C List *self] = CallByName List.66 List.285 List.289;
|
||||
inc List.671;
|
||||
let List.672 : [<r>C I64, C List *self] = CallByName List.66 List.286 List.289;
|
||||
inc List.672;
|
||||
let List.291 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.671 List.672;
|
||||
let List.667 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.287 List.291;
|
||||
let List.669 : U64 = 1i64;
|
||||
let List.668 : U64 = CallByName Num.51 List.289 List.669;
|
||||
jump List.663 List.285 List.286 List.667 List.288 List.668 List.290;
|
||||
else
|
||||
let List.653 : {} = Struct {};
|
||||
let List.652 : [C {}, C {}] = TagId(0) List.653;
|
||||
ret List.652;
|
||||
|
||||
procedure List.56 (List.237, List.238):
|
||||
let List.633 : {} = Struct {};
|
||||
let List.625 : [C {}, C {}] = CallByName List.107 List.237 List.633 List.238;
|
||||
let List.630 : U8 = 1i64;
|
||||
let List.631 : U8 = GetTagId List.625;
|
||||
let List.632 : Int1 = lowlevel Eq List.630 List.631;
|
||||
if List.632 then
|
||||
let List.626 : Int1 = CallByName Bool.2;
|
||||
ret List.626;
|
||||
else
|
||||
let List.627 : Int1 = CallByName Bool.1;
|
||||
ret List.627;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.623 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.623;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.651 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.651;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.650 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.650;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.670 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.670;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.671 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.671;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.667 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.667;
|
||||
|
||||
procedure List.80 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
|
||||
joinpoint List.638 List.539 List.540 List.541 List.542 List.543:
|
||||
let List.640 : Int1 = CallByName Num.22 List.542 List.543;
|
||||
if List.640 then
|
||||
let List.649 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.539 List.542;
|
||||
inc List.649;
|
||||
let List.641 : [C {}, C {}] = CallByName List.239 List.540 List.649 List.541;
|
||||
let List.646 : U8 = 1i64;
|
||||
let List.647 : U8 = GetTagId List.641;
|
||||
let List.648 : Int1 = lowlevel Eq List.646 List.647;
|
||||
if List.648 then
|
||||
let List.544 : {} = UnionAtIndex (Id 1) (Index 0) List.641;
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : U64 = CallByName Num.51 List.542 List.644;
|
||||
jump List.638 List.539 List.544 List.541 List.643 List.543;
|
||||
else
|
||||
dec List.539;
|
||||
let List.545 : {} = UnionAtIndex (Id 0) (Index 0) List.641;
|
||||
let List.645 : [C {}, C {}] = TagId(0) List.545;
|
||||
ret List.645;
|
||||
else
|
||||
dec List.539;
|
||||
let List.639 : [C {}, C {}] = TagId(1) List.540;
|
||||
ret List.639;
|
||||
in
|
||||
inc #Derived_gen.7;
|
||||
jump List.638 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
|
||||
|
||||
procedure List.97 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6):
|
||||
joinpoint List.660 List.282 List.283 List.284 List.285 List.286 List.287:
|
||||
let List.662 : Int1 = CallByName Num.22 List.286 List.287;
|
||||
if List.662 then
|
||||
let List.668 : [<r>C I64, C List *self] = CallByName List.66 List.282 List.286;
|
||||
inc List.668;
|
||||
let List.669 : [<r>C I64, C List *self] = CallByName List.66 List.283 List.286;
|
||||
inc List.669;
|
||||
let List.288 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.668 List.669;
|
||||
let List.664 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.284 List.288;
|
||||
let List.666 : U64 = 1i64;
|
||||
let List.665 : U64 = CallByName Num.51 List.286 List.666;
|
||||
jump List.660 List.282 List.283 List.664 List.285 List.665 List.287;
|
||||
else
|
||||
dec List.283;
|
||||
dec List.282;
|
||||
ret List.284;
|
||||
dec List.286;
|
||||
dec List.285;
|
||||
ret List.287;
|
||||
in
|
||||
inc #Derived_gen.1;
|
||||
inc #Derived_gen.2;
|
||||
jump List.660 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6;
|
||||
jump List.663 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6;
|
||||
|
||||
procedure Num.148 (Num.223, Num.224):
|
||||
let Num.286 : Int1 = CallByName Num.22 Num.223 Num.224;
|
||||
if Num.286 then
|
||||
ret Num.223;
|
||||
procedure List.110 (List.539, List.540, List.541):
|
||||
let List.639 : U64 = 0i64;
|
||||
let List.640 : U64 = CallByName List.6 List.539;
|
||||
let List.638 : [C {}, C {}] = CallByName List.80 List.539 List.540 List.541 List.639 List.640;
|
||||
ret List.638;
|
||||
|
||||
procedure List.23 (List.281, List.282, List.283):
|
||||
let List.675 : U64 = CallByName List.6 List.281;
|
||||
let List.676 : U64 = CallByName List.6 List.282;
|
||||
let List.284 : U64 = CallByName Num.148 List.675 List.676;
|
||||
let List.661 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.284;
|
||||
let List.662 : U64 = 0i64;
|
||||
let List.660 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.100 List.281 List.282 List.661 List.283 List.662 List.284;
|
||||
ret List.660;
|
||||
|
||||
procedure List.242 (List.627, List.243, List.241):
|
||||
let List.657 : Int1 = CallByName Test.1 List.243;
|
||||
if List.657 then
|
||||
let List.659 : {} = Struct {};
|
||||
let List.658 : [C {}, C {}] = TagId(1) List.659;
|
||||
ret List.658;
|
||||
else
|
||||
ret Num.224;
|
||||
let List.656 : {} = Struct {};
|
||||
let List.655 : [C {}, C {}] = TagId(0) List.656;
|
||||
ret List.655;
|
||||
|
||||
procedure List.56 (List.240, List.241):
|
||||
let List.636 : {} = Struct {};
|
||||
let List.628 : [C {}, C {}] = CallByName List.110 List.240 List.636 List.241;
|
||||
let List.633 : U8 = 1i64;
|
||||
let List.634 : U8 = GetTagId List.628;
|
||||
let List.635 : Int1 = lowlevel Eq List.633 List.634;
|
||||
if List.635 then
|
||||
let List.629 : Int1 = CallByName Bool.2;
|
||||
ret List.629;
|
||||
else
|
||||
let List.630 : Int1 = CallByName Bool.1;
|
||||
ret List.630;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.626 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.626;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.654 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.654;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.653 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.653;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.673 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.673;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.674 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.674;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.670 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.670;
|
||||
|
||||
procedure List.80 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
|
||||
joinpoint List.641 List.542 List.543 List.544 List.545 List.546:
|
||||
let List.643 : Int1 = CallByName Num.22 List.545 List.546;
|
||||
if List.643 then
|
||||
let List.652 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.542 List.545;
|
||||
inc List.652;
|
||||
let List.644 : [C {}, C {}] = CallByName List.242 List.543 List.652 List.544;
|
||||
let List.649 : U8 = 1i64;
|
||||
let List.650 : U8 = GetTagId List.644;
|
||||
let List.651 : Int1 = lowlevel Eq List.649 List.650;
|
||||
if List.651 then
|
||||
let List.547 : {} = UnionAtIndex (Id 1) (Index 0) List.644;
|
||||
let List.647 : U64 = 1i64;
|
||||
let List.646 : U64 = CallByName Num.51 List.545 List.647;
|
||||
jump List.641 List.542 List.547 List.544 List.646 List.546;
|
||||
else
|
||||
dec List.542;
|
||||
let List.548 : {} = UnionAtIndex (Id 0) (Index 0) List.644;
|
||||
let List.648 : [C {}, C {}] = TagId(0) List.548;
|
||||
ret List.648;
|
||||
else
|
||||
dec List.542;
|
||||
let List.642 : [C {}, C {}] = TagId(1) List.543;
|
||||
ret List.642;
|
||||
in
|
||||
inc #Derived_gen.7;
|
||||
jump List.641 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
|
||||
|
||||
procedure Num.148 (Num.225, Num.226):
|
||||
let Num.288 : Int1 = CallByName Num.22 Num.225 Num.226;
|
||||
if Num.288 then
|
||||
ret Num.225;
|
||||
else
|
||||
ret Num.226;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.282 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0):
|
||||
joinpoint Test.26 Test.6:
|
||||
|
@ -6,43 +6,43 @@ procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
|
||||
ret Bool.24;
|
||||
|
||||
procedure Decode.24 (Decode.101):
|
||||
ret Decode.101;
|
||||
procedure Decode.24 (Decode.105):
|
||||
ret Decode.105;
|
||||
|
||||
procedure Decode.25 (Decode.102, Decode.121, Decode.104):
|
||||
let Decode.124 : {List U8, [C {}, C Str]} = CallByName Test.76 Decode.102 Decode.104;
|
||||
ret Decode.124;
|
||||
procedure Decode.25 (Decode.106, Decode.125, Decode.108):
|
||||
let Decode.128 : {List U8, [C {}, C Str]} = CallByName Test.76 Decode.106 Decode.108;
|
||||
ret Decode.128;
|
||||
|
||||
procedure Decode.26 (Decode.105, Decode.106):
|
||||
let Decode.123 : {} = CallByName Test.15;
|
||||
let Decode.122 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.105 Decode.123 Decode.106;
|
||||
ret Decode.122;
|
||||
procedure Decode.26 (Decode.109, Decode.110):
|
||||
let Decode.127 : {} = CallByName Test.15;
|
||||
let Decode.126 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.109 Decode.127 Decode.110;
|
||||
ret Decode.126;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.241;
|
||||
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
ret Str.245;
|
||||
|
||||
procedure Str.27 (Str.78):
|
||||
let Str.232 : [C {}, C I64] = CallByName Str.60 Str.78;
|
||||
ret Str.232;
|
||||
procedure Str.27 (Str.82):
|
||||
let Str.236 : [C {}, C I64] = CallByName Str.64 Str.82;
|
||||
ret Str.236;
|
||||
|
||||
procedure Str.42 (#Attr.2):
|
||||
let Str.240 : {I64, U8} = lowlevel StrToNum #Attr.2;
|
||||
ret Str.240;
|
||||
let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
|
||||
ret Str.244;
|
||||
|
||||
procedure Str.60 (Str.185):
|
||||
let Str.186 : {I64, U8} = CallByName Str.42 Str.185;
|
||||
let Str.238 : U8 = StructAtIndex 1 Str.186;
|
||||
let Str.239 : U8 = 0i64;
|
||||
let Str.235 : Int1 = CallByName Bool.11 Str.238 Str.239;
|
||||
if Str.235 then
|
||||
let Str.237 : I64 = StructAtIndex 0 Str.186;
|
||||
let Str.236 : [C {}, C I64] = TagId(1) Str.237;
|
||||
ret Str.236;
|
||||
procedure Str.64 (Str.189):
|
||||
let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
|
||||
let Str.242 : U8 = StructAtIndex 1 Str.190;
|
||||
let Str.243 : U8 = 0i64;
|
||||
let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
|
||||
if Str.239 then
|
||||
let Str.241 : I64 = StructAtIndex 0 Str.190;
|
||||
let Str.240 : [C {}, C I64] = TagId(1) Str.241;
|
||||
ret Str.240;
|
||||
else
|
||||
let Str.234 : {} = Struct {};
|
||||
let Str.233 : [C {}, C I64] = TagId(0) Str.234;
|
||||
ret Str.233;
|
||||
let Str.238 : {} = Struct {};
|
||||
let Str.237 : [C {}, C I64] = TagId(0) Str.238;
|
||||
ret Str.237;
|
||||
|
||||
procedure Test.103 ():
|
||||
let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
|
||||
joinpoint Test.12 Test.2 Test.3:
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.279 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.279;
|
||||
let Num.281 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.280 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.280;
|
||||
let Num.282 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.1 (Test.4):
|
||||
let Test.13 : [C U8, C U64] = TagId(1) Test.4;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;
|
||||
|
@ -7,12 +7,12 @@ procedure Bool.2 ():
|
||||
ret Bool.24;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.0 (Test.8):
|
||||
let Test.20 : Int1 = CallByName Bool.2;
|
||||
|
@ -1,41 +1,41 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.623 : U64 = 0i64;
|
||||
let List.624 : U64 = CallByName List.6 List.163;
|
||||
let List.622 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
|
||||
ret List.622;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.166;
|
||||
let List.625 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.633;
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.632 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.632;
|
||||
let List.635 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
|
||||
procedure List.92 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.627 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.627 then
|
||||
let List.631 : [<rnu>C *self, <null>] = CallByName List.66 List.166 List.169;
|
||||
inc List.631;
|
||||
let List.171 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.167 List.631;
|
||||
let List.630 : U64 = 1i64;
|
||||
let List.629 : U64 = CallByName Num.51 List.169 List.630;
|
||||
jump List.625 List.166 List.171 List.168 List.629 List.170;
|
||||
procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.630 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.630 then
|
||||
let List.634 : [<rnu>C *self, <null>] = CallByName List.66 List.169 List.172;
|
||||
inc List.634;
|
||||
let List.174 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.170 List.634;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.172 List.633;
|
||||
jump List.628 List.169 List.174 List.171 List.632 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.0;
|
||||
jump List.625 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
jump List.628 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.7 (Test.11, Test.12):
|
||||
let Test.17 : {[<rnu>C *self, <null>], [<rnu><null>, C {[<rnu>C *self, <null>], *self}]} = Struct {Test.12, Test.11};
|
||||
|
@ -1,11 +1,11 @@
|
||||
procedure Num.31 (Num.217):
|
||||
let Num.280 : I64 = 2i64;
|
||||
let Num.279 : Int1 = CallByName Num.86 Num.217 Num.280;
|
||||
ret Num.279;
|
||||
procedure Num.31 (Num.219):
|
||||
let Num.282 : I64 = 2i64;
|
||||
let Num.281 : Int1 = CallByName Num.86 Num.219 Num.282;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.86 (#Attr.2, #Attr.3):
|
||||
let Num.281 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Test.2 (#Derived_gen.0, #Derived_gen.1):
|
||||
let #Derived_gen.3 : [<rnu><null>, C I64 *self] = NullPointer;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.10 (Test.11):
|
||||
let Test.28 : I64 = 1i64;
|
||||
|
18
crates/compiler/test_mono/generated/list_append.txt
generated
18
crates/compiler/test_mono/generated/list_append.txt
generated
@ -1,16 +1,16 @@
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.625 : U64 = 1i64;
|
||||
let List.623 : List I64 = CallByName List.70 List.127 List.625;
|
||||
let List.622 : List I64 = CallByName List.71 List.623 List.128;
|
||||
ret List.622;
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.628 : U64 = 1i64;
|
||||
let List.626 : List I64 = CallByName List.70 List.130 List.628;
|
||||
let List.625 : List I64 = CallByName List.71 List.626 List.131;
|
||||
ret List.625;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.626 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.626;
|
||||
let List.629 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.629;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.624 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.624;
|
||||
let List.627 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : List I64 = Array [1i64];
|
||||
|
@ -1,16 +1,16 @@
|
||||
procedure List.4 (List.127, List.128):
|
||||
let List.625 : U64 = 1i64;
|
||||
let List.623 : List I64 = CallByName List.70 List.127 List.625;
|
||||
let List.622 : List I64 = CallByName List.71 List.623 List.128;
|
||||
ret List.622;
|
||||
procedure List.4 (List.130, List.131):
|
||||
let List.628 : U64 = 1i64;
|
||||
let List.626 : List I64 = CallByName List.70 List.130 List.628;
|
||||
let List.625 : List I64 = CallByName List.71 List.626 List.131;
|
||||
ret List.625;
|
||||
|
||||
procedure List.70 (#Attr.2, #Attr.3):
|
||||
let List.626 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.626;
|
||||
let List.629 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.629;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.624 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.624;
|
||||
let List.627 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.6 : I64 = 42i64;
|
||||
|
@ -1,33 +1,33 @@
|
||||
procedure List.3 (List.119, List.120, List.121):
|
||||
let List.625 : {List I64, I64} = CallByName List.64 List.119 List.120 List.121;
|
||||
let List.624 : List I64 = StructAtIndex 0 List.625;
|
||||
ret List.624;
|
||||
procedure List.3 (List.122, List.123, List.124):
|
||||
let List.628 : {List I64, I64} = CallByName List.64 List.122 List.123 List.124;
|
||||
let List.627 : List I64 = StructAtIndex 0 List.628;
|
||||
ret List.627;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.623 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.623;
|
||||
|
||||
procedure List.64 (List.116, List.117, List.118):
|
||||
let List.630 : U64 = CallByName List.6 List.116;
|
||||
let List.627 : Int1 = CallByName Num.22 List.117 List.630;
|
||||
if List.627 then
|
||||
let List.628 : {List I64, I64} = CallByName List.67 List.116 List.117 List.118;
|
||||
ret List.628;
|
||||
else
|
||||
let List.626 : {List I64, I64} = Struct {List.116, List.118};
|
||||
let List.626 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.626;
|
||||
|
||||
procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.629 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
procedure List.64 (List.119, List.120, List.121):
|
||||
let List.633 : U64 = CallByName List.6 List.119;
|
||||
let List.630 : Int1 = CallByName Num.22 List.120 List.633;
|
||||
if List.630 then
|
||||
let List.631 : {List I64, I64} = CallByName List.67 List.119 List.120 List.121;
|
||||
ret List.631;
|
||||
else
|
||||
let List.629 : {List I64, I64} = Struct {List.119, List.121};
|
||||
ret List.629;
|
||||
|
||||
procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.632 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.632;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.1 ():
|
||||
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
32
crates/compiler/test_mono/generated/list_get.txt
generated
32
crates/compiler/test_mono/generated/list_get.txt
generated
@ -1,26 +1,26 @@
|
||||
procedure List.2 (List.111, List.112):
|
||||
let List.628 : U64 = CallByName List.6 List.111;
|
||||
let List.624 : Int1 = CallByName Num.22 List.112 List.628;
|
||||
if List.624 then
|
||||
let List.626 : I64 = CallByName List.66 List.111 List.112;
|
||||
let List.625 : [C {}, C I64] = TagId(1) List.626;
|
||||
ret List.625;
|
||||
procedure List.2 (List.114, List.115):
|
||||
let List.631 : U64 = CallByName List.6 List.114;
|
||||
let List.627 : Int1 = CallByName Num.22 List.115 List.631;
|
||||
if List.627 then
|
||||
let List.629 : I64 = CallByName List.66 List.114 List.115;
|
||||
let List.628 : [C {}, C I64] = TagId(1) List.629;
|
||||
ret List.628;
|
||||
else
|
||||
let List.623 : {} = Struct {};
|
||||
let List.622 : [C {}, C I64] = TagId(0) List.623;
|
||||
ret List.622;
|
||||
let List.626 : {} = Struct {};
|
||||
let List.625 : [C {}, C I64] = TagId(0) List.626;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.629 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.629;
|
||||
let List.632 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.632;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.627 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
let List.630 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.630;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
12
crates/compiler/test_mono/generated/list_len.txt
generated
12
crates/compiler/test_mono/generated/list_len.txt
generated
@ -1,14 +1,14 @@
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.622;
|
||||
let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.623 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.623;
|
||||
let List.626 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.626;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
@ -1,82 +1,82 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.634 : U64 = 0i64;
|
||||
let List.635 : U64 = CallByName List.6 List.163;
|
||||
let List.633 : List Str = CallByName List.92 List.163 List.164 List.165 List.634 List.635;
|
||||
ret List.633;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.637 : U64 = 0i64;
|
||||
let List.638 : U64 = CallByName List.6 List.166;
|
||||
let List.636 : List Str = CallByName List.95 List.166 List.167 List.168 List.637 List.638;
|
||||
ret List.636;
|
||||
|
||||
procedure List.2 (List.111, List.112):
|
||||
let List.628 : U64 = CallByName List.6 List.111;
|
||||
let List.624 : Int1 = CallByName Num.22 List.112 List.628;
|
||||
if List.624 then
|
||||
let List.626 : Str = CallByName List.66 List.111 List.112;
|
||||
inc List.626;
|
||||
let List.625 : [C {}, C Str] = TagId(1) List.626;
|
||||
ret List.625;
|
||||
procedure List.2 (List.114, List.115):
|
||||
let List.631 : U64 = CallByName List.6 List.114;
|
||||
let List.627 : Int1 = CallByName Num.22 List.115 List.631;
|
||||
if List.627 then
|
||||
let List.629 : Str = CallByName List.66 List.114 List.115;
|
||||
inc List.629;
|
||||
let List.628 : [C {}, C Str] = TagId(1) List.629;
|
||||
ret List.628;
|
||||
else
|
||||
let List.623 : {} = Struct {};
|
||||
let List.622 : [C {}, C Str] = TagId(0) List.623;
|
||||
ret List.622;
|
||||
let List.626 : {} = Struct {};
|
||||
let List.625 : [C {}, C Str] = TagId(0) List.626;
|
||||
ret List.625;
|
||||
|
||||
procedure List.275 (List.276, List.277, List.273):
|
||||
let List.645 : Str = CallByName Test.3 List.277;
|
||||
let List.644 : List Str = CallByName List.71 List.276 List.645;
|
||||
ret List.644;
|
||||
|
||||
procedure List.5 (List.272, List.273):
|
||||
let List.274 : U64 = CallByName List.6 List.272;
|
||||
let List.631 : List Str = CallByName List.68 List.274;
|
||||
let List.630 : List Str = CallByName List.18 List.272 List.631 List.273;
|
||||
ret List.630;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.629 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.629;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.627 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.647 : List Str = lowlevel ListWithCapacity #Attr.2;
|
||||
procedure List.278 (List.279, List.280, List.276):
|
||||
let List.648 : Str = CallByName Test.3 List.280;
|
||||
let List.647 : List Str = CallByName List.71 List.279 List.648;
|
||||
ret List.647;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.646 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.646;
|
||||
procedure List.5 (List.275, List.276):
|
||||
let List.277 : U64 = CallByName List.6 List.275;
|
||||
let List.634 : List Str = CallByName List.68 List.277;
|
||||
let List.633 : List Str = CallByName List.18 List.275 List.634 List.276;
|
||||
ret List.633;
|
||||
|
||||
procedure List.92 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
|
||||
joinpoint List.636 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.638 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.638 then
|
||||
let List.642 : Str = CallByName List.66 List.166 List.169;
|
||||
inc List.642;
|
||||
let List.171 : List Str = CallByName List.275 List.167 List.642 List.168;
|
||||
dec List.642;
|
||||
let List.641 : U64 = 1i64;
|
||||
let List.640 : U64 = CallByName Num.51 List.169 List.641;
|
||||
jump List.636 List.166 List.171 List.168 List.640 List.170;
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.632 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.632;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.630 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.630;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.650 : List Str = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.649 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.649;
|
||||
|
||||
procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.639 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.641 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.641 then
|
||||
let List.645 : Str = CallByName List.66 List.169 List.172;
|
||||
inc List.645;
|
||||
let List.174 : List Str = CallByName List.278 List.170 List.645 List.171;
|
||||
dec List.645;
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : U64 = CallByName Num.51 List.172 List.644;
|
||||
jump List.639 List.169 List.174 List.171 List.643 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.3;
|
||||
jump List.636 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
|
||||
inc #Derived_gen.0;
|
||||
jump List.639 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Str.16 (#Attr.2, #Attr.3):
|
||||
let Str.232 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
|
||||
ret Str.232;
|
||||
let Str.236 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
|
||||
ret Str.236;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.233 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.233;
|
||||
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.237;
|
||||
|
||||
procedure Test.1 ():
|
||||
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";
|
||||
|
@ -1,77 +1,77 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.634 : U64 = 0i64;
|
||||
let List.635 : U64 = CallByName List.6 List.163;
|
||||
let List.633 : List Str = CallByName List.92 List.163 List.164 List.165 List.634 List.635;
|
||||
ret List.633;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.637 : U64 = 0i64;
|
||||
let List.638 : U64 = CallByName List.6 List.166;
|
||||
let List.636 : List Str = CallByName List.95 List.166 List.167 List.168 List.637 List.638;
|
||||
ret List.636;
|
||||
|
||||
procedure List.2 (List.111, List.112):
|
||||
let List.628 : U64 = CallByName List.6 List.111;
|
||||
let List.624 : Int1 = CallByName Num.22 List.112 List.628;
|
||||
if List.624 then
|
||||
let List.626 : Str = CallByName List.66 List.111 List.112;
|
||||
inc List.626;
|
||||
let List.625 : [C {}, C Str] = TagId(1) List.626;
|
||||
ret List.625;
|
||||
procedure List.2 (List.114, List.115):
|
||||
let List.631 : U64 = CallByName List.6 List.114;
|
||||
let List.627 : Int1 = CallByName Num.22 List.115 List.631;
|
||||
if List.627 then
|
||||
let List.629 : Str = CallByName List.66 List.114 List.115;
|
||||
inc List.629;
|
||||
let List.628 : [C {}, C Str] = TagId(1) List.629;
|
||||
ret List.628;
|
||||
else
|
||||
let List.623 : {} = Struct {};
|
||||
let List.622 : [C {}, C Str] = TagId(0) List.623;
|
||||
ret List.622;
|
||||
let List.626 : {} = Struct {};
|
||||
let List.625 : [C {}, C Str] = TagId(0) List.626;
|
||||
ret List.625;
|
||||
|
||||
procedure List.275 (List.276, List.277, List.273):
|
||||
let List.645 : Str = CallByName Test.3 List.277;
|
||||
let List.644 : List Str = CallByName List.71 List.276 List.645;
|
||||
ret List.644;
|
||||
|
||||
procedure List.5 (List.272, List.273):
|
||||
let List.274 : U64 = CallByName List.6 List.272;
|
||||
let List.631 : List Str = CallByName List.68 List.274;
|
||||
let List.630 : List Str = CallByName List.18 List.272 List.631 List.273;
|
||||
ret List.630;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.629 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.629;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.627 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.647 : List Str = lowlevel ListWithCapacity #Attr.2;
|
||||
procedure List.278 (List.279, List.280, List.276):
|
||||
let List.648 : Str = CallByName Test.3 List.280;
|
||||
let List.647 : List Str = CallByName List.71 List.279 List.648;
|
||||
ret List.647;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.646 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.646;
|
||||
procedure List.5 (List.275, List.276):
|
||||
let List.277 : U64 = CallByName List.6 List.275;
|
||||
let List.634 : List Str = CallByName List.68 List.277;
|
||||
let List.633 : List Str = CallByName List.18 List.275 List.634 List.276;
|
||||
ret List.633;
|
||||
|
||||
procedure List.92 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
|
||||
joinpoint List.636 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.638 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.638 then
|
||||
let List.642 : Str = CallByName List.66 List.166 List.169;
|
||||
inc List.642;
|
||||
let List.171 : List Str = CallByName List.275 List.167 List.642 List.168;
|
||||
let List.641 : U64 = 1i64;
|
||||
let List.640 : U64 = CallByName Num.51 List.169 List.641;
|
||||
jump List.636 List.166 List.171 List.168 List.640 List.170;
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.632 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.632;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.630 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.630;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.650 : List Str = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.650;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.649 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.649;
|
||||
|
||||
procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.639 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.641 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.641 then
|
||||
let List.645 : Str = CallByName List.66 List.169 List.172;
|
||||
inc List.645;
|
||||
let List.174 : List Str = CallByName List.278 List.170 List.645 List.171;
|
||||
let List.644 : U64 = 1i64;
|
||||
let List.643 : U64 = CallByName Num.51 List.172 List.644;
|
||||
jump List.639 List.169 List.174 List.171 List.643 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.3;
|
||||
jump List.636 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
|
||||
inc #Derived_gen.0;
|
||||
jump List.639 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.233 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.233;
|
||||
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.237;
|
||||
|
||||
procedure Test.1 ():
|
||||
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";
|
||||
|
@ -1,78 +1,78 @@
|
||||
procedure List.18 (List.163, List.164, List.165):
|
||||
let List.626 : U64 = 0i64;
|
||||
let List.627 : U64 = CallByName List.6 List.163;
|
||||
let List.625 : List U8 = CallByName List.92 List.163 List.164 List.165 List.626 List.627;
|
||||
ret List.625;
|
||||
procedure List.18 (List.166, List.167, List.168):
|
||||
let List.629 : U64 = 0i64;
|
||||
let List.630 : U64 = CallByName List.6 List.166;
|
||||
let List.628 : List U8 = CallByName List.95 List.166 List.167 List.168 List.629 List.630;
|
||||
ret List.628;
|
||||
|
||||
procedure List.275 (List.276, List.277, List.273):
|
||||
let List.641 : U8 = GetTagId List.273;
|
||||
joinpoint List.642 List.639:
|
||||
let List.638 : List U8 = CallByName List.71 List.276 List.639;
|
||||
ret List.638;
|
||||
procedure List.278 (List.279, List.280, List.276):
|
||||
let List.644 : U8 = GetTagId List.276;
|
||||
joinpoint List.645 List.642:
|
||||
let List.641 : List U8 = CallByName List.71 List.279 List.642;
|
||||
ret List.641;
|
||||
in
|
||||
switch List.641:
|
||||
switch List.644:
|
||||
case 0:
|
||||
let List.643 : U8 = CallByName Test.4 List.277 List.273;
|
||||
jump List.642 List.643;
|
||||
let List.646 : U8 = CallByName Test.4 List.280 List.276;
|
||||
jump List.645 List.646;
|
||||
|
||||
case 1:
|
||||
let List.643 : U8 = CallByName Test.6 List.277 List.273;
|
||||
jump List.642 List.643;
|
||||
let List.646 : U8 = CallByName Test.6 List.280 List.276;
|
||||
jump List.645 List.646;
|
||||
|
||||
default:
|
||||
let List.643 : U8 = CallByName Test.8 List.277;
|
||||
jump List.642 List.643;
|
||||
let List.646 : U8 = CallByName Test.8 List.280;
|
||||
jump List.645 List.646;
|
||||
|
||||
|
||||
procedure List.5 (List.272, List.273):
|
||||
let List.274 : U64 = CallByName List.6 List.272;
|
||||
let List.623 : List U8 = CallByName List.68 List.274;
|
||||
let List.622 : List U8 = CallByName List.18 List.272 List.623 List.273;
|
||||
ret List.622;
|
||||
procedure List.5 (List.275, List.276):
|
||||
let List.277 : U64 = CallByName List.6 List.275;
|
||||
let List.626 : List U8 = CallByName List.68 List.277;
|
||||
let List.625 : List U8 = CallByName List.18 List.275 List.626 List.276;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.636;
|
||||
let List.639 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.639;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.635 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.635;
|
||||
let List.638 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.638;
|
||||
|
||||
procedure List.68 (#Attr.2):
|
||||
let List.644 : List U8 = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.644;
|
||||
let List.647 : List U8 = lowlevel ListWithCapacity #Attr.2;
|
||||
ret List.647;
|
||||
|
||||
procedure List.71 (#Attr.2, #Attr.3):
|
||||
let List.640 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.640;
|
||||
let List.643 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.643;
|
||||
|
||||
procedure List.92 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.628 List.166 List.167 List.168 List.169 List.170:
|
||||
let List.630 : Int1 = CallByName Num.22 List.169 List.170;
|
||||
if List.630 then
|
||||
let List.634 : U8 = CallByName List.66 List.166 List.169;
|
||||
let List.171 : List U8 = CallByName List.275 List.167 List.634 List.168;
|
||||
let List.633 : U64 = 1i64;
|
||||
let List.632 : U64 = CallByName Num.51 List.169 List.633;
|
||||
jump List.628 List.166 List.171 List.168 List.632 List.170;
|
||||
procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
|
||||
joinpoint List.631 List.169 List.170 List.171 List.172 List.173:
|
||||
let List.633 : Int1 = CallByName Num.22 List.172 List.173;
|
||||
if List.633 then
|
||||
let List.637 : U8 = CallByName List.66 List.169 List.172;
|
||||
let List.174 : List U8 = CallByName List.278 List.170 List.637 List.171;
|
||||
let List.636 : U64 = 1i64;
|
||||
let List.635 : U64 = CallByName Num.51 List.172 List.636;
|
||||
jump List.631 List.169 List.174 List.171 List.635 List.173;
|
||||
else
|
||||
dec List.166;
|
||||
ret List.167;
|
||||
dec List.169;
|
||||
ret List.170;
|
||||
in
|
||||
inc #Derived_gen.0;
|
||||
jump List.628 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
jump List.631 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
let Num.283 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.285;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.282 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Test.4 (Test.5, #Attr.12):
|
||||
let Test.16 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
|
@ -1,29 +1,29 @@
|
||||
procedure List.3 (List.119, List.120, List.121):
|
||||
let List.623 : {List I64, I64} = CallByName List.64 List.119 List.120 List.121;
|
||||
let List.622 : List I64 = StructAtIndex 0 List.623;
|
||||
ret List.622;
|
||||
procedure List.3 (List.122, List.123, List.124):
|
||||
let List.626 : {List I64, I64} = CallByName List.64 List.122 List.123 List.124;
|
||||
let List.625 : List I64 = StructAtIndex 0 List.626;
|
||||
ret List.625;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.629 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
let List.632 : U64 = lowlevel ListLenU64 #Attr.2;
|
||||
ret List.632;
|
||||
|
||||
procedure List.64 (List.119, List.120, List.121):
|
||||
let List.631 : U64 = CallByName List.6 List.119;
|
||||
let List.628 : Int1 = CallByName Num.22 List.120 List.631;
|
||||
if List.628 then
|
||||
let List.629 : {List I64, I64} = CallByName List.67 List.119 List.120 List.121;
|
||||
ret List.629;
|
||||
|
||||
procedure List.64 (List.116, List.117, List.118):
|
||||
let List.628 : U64 = CallByName List.6 List.116;
|
||||
let List.625 : Int1 = CallByName Num.22 List.117 List.628;
|
||||
if List.625 then
|
||||
let List.626 : {List I64, I64} = CallByName List.67 List.116 List.117 List.118;
|
||||
ret List.626;
|
||||
else
|
||||
let List.624 : {List I64, I64} = Struct {List.116, List.118};
|
||||
ret List.624;
|
||||
|
||||
procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.627 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
let List.627 : {List I64, I64} = Struct {List.119, List.121};
|
||||
ret List.627;
|
||||
|
||||
procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.630 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.630;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
let Test.6 : U64 = 0i64;
|
||||
|
@ -1,15 +1,15 @@
|
||||
procedure List.28 (#Attr.2, #Attr.3):
|
||||
let List.624 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
ret List.624;
|
||||
let List.627 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
ret List.627;
|
||||
|
||||
procedure List.59 (List.378):
|
||||
let List.623 : {} = Struct {};
|
||||
let List.622 : List I64 = CallByName List.28 List.378 List.623;
|
||||
ret List.622;
|
||||
procedure List.59 (List.381):
|
||||
let List.626 : {} = Struct {};
|
||||
let List.625 : List I64 = CallByName List.28 List.381 List.626;
|
||||
ret List.625;
|
||||
|
||||
procedure Num.46 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.281 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.280 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.7 : I64 = 1i64;
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user