QualifiedType AmbiguousTypeParamType::forType(QualifiedType base, const Type * match,
unsigned paramIndex) {
base = dealias(base);
match = dealias(match);
switch (base->typeClass()) {
case Type::Class:
case Type::Struct:
case Type::Interface:
case Type::Protocol: {
const CompositeType * ctBase = static_cast<const CompositeType *>(base.type());
if (const CompositeType * ctMatch = dyn_cast_or_null<CompositeType>(match)) {
if (ctMatch != NULL) {
base = ctBase->findBaseSpecializing(ctMatch);
if (!base) {
return QualifiedType();
}
}
if (paramIndex >= base->numTypeParams()) {
return QualifiedType();
} else {
return base->typeParam(paramIndex);
}
}
return QualifiedType();
}
case Type::NAddress:
case Type::NArray:
case Type::FlexibleArray: {
if (paramIndex == 0 && (match == NULL || base->typeClass() == match->typeClass())) {
return base->typeParam(0);
}
return QualifiedType();
}
case Type::Tuple: {
if (match != NULL || paramIndex >= base->numTypeParams()) {
return QualifiedType();
} else {
return base->typeParam(paramIndex);
}
}
case Type::AmbiguousParameter:
case Type::AmbiguousResult:
case Type::AmbiguousTypeParam:
case Type::AmbiguousPhi:
case Type::Assignment: {
QualifiedTypeSet expansion;
base.expand(expansion);
if (expansion.size() == 1) {
return forType(*expansion.begin(), match, paramIndex);
}
return new AmbiguousTypeParamType(base, match, paramIndex);
}
default:
return QualifiedType();
}
}
TypeLiteralType * TypeLiteralType::get(const Type * literalType) {
DASSERT(literalType != NULL);
literalType = dealias(literalType);
TypeMap::iterator it = uniqueTypes_.find(literalType);
if (it != uniqueTypes_.end()) {
return it->second;
}
TypeLiteralType * addrType = new TypeLiteralType(literalType);
uniqueTypes_[literalType] = addrType;
return addrType;
}
int
run_compilation_passes (struct ast **ss)
{
int ret = 0;
ret = ret || semantic (*ss);
ret = ret || transform (ss);
ret = ret || dealias (ss);
ret = ret || collect_vars (*ss);
ret = ret || optimizer (ss);
ret = ret || gen_code (*ss);
AST_FREE (*ss);
return ret;
}
