void loadDependent(ModulePtr m, vector<string> *sourceFiles, ImportPtr dependent, bool verbose) {
ImportPtr x = dependent;
x->module = loadModuleByName(x->dottedName, sourceFiles, verbose);
switch (x->importKind) {
case IMPORT_MODULE : {
ImportModule *im = (ImportModule *)x.ptr();
IdentifierPtr name = NULL;
if (im->alias.ptr()) {
name = im->alias;
m->importedModuleNames[im->alias->str].module = x->module;
} else {
llvm::ArrayRef<IdentifierPtr> parts = im->dottedName->parts;
if (parts.size() == 1)
name = parts[0];
else if (x->visibility == PUBLIC)
error(x->location,
"public imports of dotted module paths must have an \"as <name>\" alias");
llvm::StringMap<ModuleLookup> *node = &m->importedModuleNames;
for (size_t i = parts.size() - 1; i >= 1; --i) {
node = &(*node)[parts[i]->str].parents;
}
(*node)[parts[0]->str].module = x->module;
}
if (name.ptr()) {
string nameStr(name->str.begin(), name->str.end());
if (m->importedNames.count(nameStr))
error(name, "name imported already: " + nameStr);
m->importedNames.insert(nameStr);
m->allSymbols[nameStr].insert(x->module.ptr());
if (x->visibility == PUBLIC)
m->publicSymbols[nameStr].insert(x->module.ptr());
}
break;
}
case IMPORT_STAR :
break;
case IMPORT_MEMBERS : {
ImportMembers *y = (ImportMembers *)x.ptr();
for (unsigned i = 0; i < y->members.size(); ++i) {
ImportedMember &z = y->members[i];
IdentifierPtr alias = z.alias.ptr() ? z.alias : z.name;
string aliasStr(alias->str.begin(), alias->str.end());
if (m->importedNames.count(aliasStr))
error(alias, "name imported already: " + aliasStr);
assert(y->aliasMap.count(aliasStr) == 0);
m->importedNames.insert(aliasStr);
y->aliasMap[aliasStr] = z.name;
}
break;
}
default :
assert(false);
}
}
void convertFreeVars(LambdaPtr x, EnvPtr env,
const string &closureDataName,
vector<string> &freeVars)
{
EnvPtr env2 = new Env(env);
for (unsigned i = 0; i < x->formalArgs.size(); ++i) {
IdentifierPtr name = x->formalArgs[i];
addLocal(env2, name, name.ptr());
}
if (x->formalVarArg.ptr()) {
addLocal(env2, x->formalVarArg, x->formalVarArg.ptr());
}
LambdaContext ctx(x->captureByRef, env, closureDataName, freeVars);
convertFreeVars(x->body, env2, ctx);
}
static void initializeVariantType(VariantTypePtr t) {
assert(!t->initialized);
EnvPtr variantEnv = new Env(t->variant->env);
{
const vector<IdentifierPtr> ¶ms = t->variant->params;
IdentifierPtr varParam = t->variant->varParam;
assert(params.size() <= t->params.size());
for (unsigned j = 0; j < params.size(); ++j)
addLocal(variantEnv, params[j], t->params[j]);
if (varParam.ptr()) {
MultiStaticPtr ms = new MultiStatic();
for (unsigned j = params.size(); j < t->params.size(); ++j)
ms->add(t->params[j]);
addLocal(variantEnv, varParam, ms.ptr());
}
else {
assert(params.size() == t->params.size());
}
}
ExprListPtr defaultInstances = t->variant->defaultInstances;
for (unsigned i = 0; i < defaultInstances->size(); ++i) {
ExprPtr x = defaultInstances->exprs[i];
TypePtr memberType = evaluateType(x, variantEnv);
t->memberTypes.push_back(memberType);
}
const vector<InstancePtr> &instances = t->variant->instances;
for (unsigned i = 0; i < instances.size(); ++i) {
InstancePtr x = instances[i];
vector<PatternCellPtr> cells;
vector<MultiPatternCellPtr> multiCells;
const vector<PatternVar> &pvars = x->patternVars;
EnvPtr patternEnv = new Env(x->env);
for (unsigned j = 0; j < pvars.size(); ++j) {
if (pvars[j].isMulti) {
MultiPatternCellPtr multiCell = new MultiPatternCell(NULL);
multiCells.push_back(multiCell);
cells.push_back(NULL);
addLocal(patternEnv, pvars[j].name, multiCell.ptr());
}
else {
PatternCellPtr cell = new PatternCell(NULL);
cells.push_back(cell);
multiCells.push_back(NULL);
addLocal(patternEnv, pvars[j].name, cell.ptr());
}
}
PatternPtr pattern = evaluateOnePattern(x->target, patternEnv);
if (!unifyPatternObj(pattern, t.ptr()))
continue;
EnvPtr staticEnv = new Env(x->env);
for (unsigned j = 0; j < pvars.size(); ++j) {
if (pvars[j].isMulti) {
MultiStaticPtr ms = derefDeep(multiCells[j].ptr());
if (!ms)
error(pvars[j].name, "unbound pattern variable");
addLocal(staticEnv, pvars[j].name, ms.ptr());
}
else {
ObjectPtr v = derefDeep(cells[j].ptr());
if (!v)
error(pvars[j].name, "unbound pattern variable");
addLocal(staticEnv, pvars[j].name, v.ptr());
}
}
if (x->predicate.ptr())
if (!evaluateBool(x->predicate, staticEnv))
continue;
TypePtr memberType = evaluateType(x->member, staticEnv);
t->memberTypes.push_back(memberType);
}
RecordPtr reprRecord = getVariantReprRecord();
vector<ObjectPtr> params;
for (unsigned i = 0; i < t->memberTypes.size(); ++i)
params.push_back(t->memberTypes[i].ptr());
t->reprType = recordType(reprRecord, params);
t->initialized = true;
}