private MidType EmitTypeExpImpl(
ResBottomType bottomType,
MidEmitEnv env)
{
// Well, bottom really means "never returns"...
return(new MidVoidType());
}
private IMidMemberRef EmitMemberTermImpl(ResGlobalMemberTerm resGlobal, MidEmitEnv env)
{
var resDecl = resGlobal.Decl;
var resModule = resGlobal.Module;
var midModule = _modules[resModule];
var midDecl = midModule.LookupMemberDecl(resDecl);
if (midDecl == null)
{
if (midModule == _module)
{
midDecl = EmitMemberDecl(
null,
resDecl,
_module.Env);
_module.InsertMemberDecl(resDecl, midDecl);
midDecl.ForceDeep();
}
else
{
throw new NotImplementedException();
}
}
return(midDecl.CreateRef(new MidGlobalMemberTerm(midDecl)));
}
private MidExp EmitExpImpl(
ResBaseExp exp,
MidEmitEnv env)
{
var inheritedDecls = env.InheritedDecls;
if (inheritedDecls == null)
{
throw new NotImplementedException();
}
var inheritedDeclsArr = inheritedDecls.ToArray();
var firstDecl = inheritedDeclsArr[0];
if (firstDecl.Init == null)
{
throw new NotImplementedException();
}
var nestedEnv = new MidDummyEmitEnv(env);
nestedEnv.InheritedDecls = inheritedDeclsArr.Skip(1);
return(EmitExpRaw(
firstDecl.Init,
nestedEnv));
}
private MidPath EmitPath(IResExp resExp, MidEmitEnv env)
{
var midType = EmitTypeExp(resExp.Type, env);
var midExp = EmitExpRaw(resExp, env);
return(env.MaybeMoveTemp <MidPath>(midExp, midType));
}
private MidExp EmitExpImpl(
ResLetExp resLet,
MidEmitEnv env)
{
var resLetType = resLet.Var.Type;
MidVal midVal = null;
if (resLetType is ResFreqQualType)
{
var resFreq = ((ResFreqQualType)resLetType).Freq;
var midElem = ((MidElementType)EmitTypeExp(resFreq, env)).Decl;
midVal = EmitValToElement(resLet.Value, midElem, env);
}
if (midVal == null)
{
midVal = EmitVal(resLet.Value, env);
}
env.Insert(
resLet.Var,
(SourceRange r) => midVal);
return(EmitExpRaw(
resLet.Body,
env));
}
private object EmitGenericArg(
IResGenericArg arg,
IResGenericParamRef param,
MidEmitEnv env)
{
return(EmitGenericArgImpl((dynamic)arg, (dynamic)param, env));
}
public MidModuleDecl(
IBuilder parent,
MidEmitContext context,
MidEmitEnv env)
: base(parent, context, env)
{
}
private MidExp EmitExpImpl(ResBreakExp exp, MidEmitEnv env)
{
MidLabel label = env.Lookup(exp.Label);
MidVal val = EmitVal(exp.Value, env);
return(new MidBreakExp(exp.Range, label, val));
}
private MidExp EmitExpImpl(
ResAttributeFetch attrFetch,
MidEmitEnv env)
{
// Get the base object to fetch attribute from:
var obj = EmitPath(attrFetch.Obj, env);
// Now, emit the attribute expression to
// its associated element:
var attrFreq = ((ResFreqQualType)attrFetch.Attribute.Type).Freq;
var attrElement = ((MidElementType)EmitTypeExp(attrFreq, env)).Decl;
var attrVal = EmitValToElement(attrFetch.Attribute, attrElement, env);
if (attrVal is MidAttributeRef)
{
// We want to avoid forcing the decl
// of the MidAttributeRef, in case it is lazy
var attrRef = (MidAttributeRef)attrVal;
return(new MidAttributeFetch(
attrFetch.Range,
obj,
attrVal.Type,
env.Lazy(() => attrRef.Decl)));
}
else
{
// some other kind of value... maybe just a literal...
return(attrVal);
}
}
public MidGlobalEmitEnv(
MidEmitEnv parent,
MidEmitContext context)
: base(parent)
{
_context = context;
}
private IMidMemberRef EmitMemberTermImpl(ResMemberBind resBind, MidEmitEnv env)
{
var obj = EmitVal(resBind.Obj, env);
var container = EmitMemberTerm(resBind.MemberSpec.Container.MemberTerm, env);
return(LookupMemberImpl((dynamic)container, (dynamic)obj, resBind.Decl, env));
}
public MidStructDecl(
IBuilder parent,
Identifier name,
MidEmitContext context,
MidEmitEnv env)
: base(parent, context, env)
{
_name = name;
}
public MidContainerDecl(
IBuilder parent,
MidEmitContext context,
MidEmitEnv env)
: base(parent)
{
_context = context;
_env = env;
}
private MidExp EmitExpImpl(IResAttributeRef resAttrib, MidEmitEnv env)
{
var wrapper = (MidAttributeWrapperMemberRef)EmitMemberTerm(resAttrib.MemberTerm, env);
var type = EmitTypeExp(resAttrib.Type, env);
return(new MidAttributeRef(resAttrib.Range, type, env.Lazy(() => {
return wrapper.Decl.Attribute;
})));
}
private MidExp EmitLocalExp(
IResExp resExp,
MidEmitEnv env,
MidElementDecl element = null)
{
var localEnv = new MidLocalEmitEnv(env, _identifiers, element, _exps);
var midExp = EmitExpRaw(resExp, localEnv);
return(localEnv.Wrap(midExp));
}
private IMidMemberRef LookupMemberImpl(
IMidMemberRef container,
MidVal obj,
IResMemberDecl resDecl,
MidEmitEnv env)
{
var midDecl = container.LookupMemberDecl(resDecl);
return(midDecl.CreateRef(new MidMemberBind(obj, midDecl)));
}
private MidMemberDecl EmitMemberDecl(
object parent,
IResMemberDecl resMemberDecl,
MidEmitEnv env)
{
return(EmitMemberDeclImpl(
(dynamic)parent,
(dynamic)resMemberDecl,
env));
}
private void BindForMemberTermImpl(
ResMemberBind memberBind,
MidEmitEnv env)
{
var objVal = EmitVal(memberBind.Obj, env);
env.Insert(
memberBind.MemberSpec.Container.ThisParameter,
(SourceRange r) => objVal);
}
private MidExp EmitExpImpl(
ResIfExp exp,
MidEmitEnv env)
{
var condExp = EmitVal(exp.Condition, env);
var thenExp = EmitLocalExp(exp.Then, env);
var elseExp = EmitLocalExp(exp.Else, env);
return(new MidIfExp(condExp, thenExp, elseExp, exp.Range));
}
public MidPipelineDecl(
IBuilder parent,
Identifier name,
MidEmitContext context,
MidEmitEnv env,
SourceRange range)
: base(parent, context, env)
{
_name = name;
_range = range;
}
public MidConceptClassDecl(
IBuilder parent,
Identifier name,
IEnumerable <IResMemberDecl> members,
MidEmitContext context,
MidEmitEnv env)
: base(parent, context, env)
{
_name = name;
_members = members.ToArray();
}
public MidFacetDecl(
IBuilder parent,
MidEmitContext context,
MidEmitEnv env,
MidPipelineDecl parentPipeline,
MidPipelineRef originalPipeline)
: base(parent, context, env)
{
_parentPipeline = parentPipeline;
_originalPipeline = originalPipeline;
}
private void BindForMemberTermImpl(
ResMemberGenericApp genericApp,
MidEmitEnv env)
{
BindForMemberTerm(genericApp.Fun.MemberTerm, env);
foreach (var pair in genericApp.Args.Zip(genericApp.Fun.Parameters, Tuple.Create))
{
EmitGenericArg(pair.Item1, pair.Item2, env);
}
}
private IMidMemberRef EmitMemberTermImpl(ResMemberGenericApp resApp, MidEmitEnv env)
{
var fun = EmitMemberTerm(resApp.Fun.MemberTerm, env);
var argEnv = new MidGenericArgEmitEnv(env);
var args = resApp.Args.Zip(resApp.Fun.Parameters,
(a, p) => EmitGenericArg(a, p, argEnv)).Eager();
return(fun.GenericApp(args));
}
private MidExp EmitExpImpl(
Resolve.ResDummyValArg exp,
MidEmitEnv env)
{
if (exp.ConcreteVal == null)
{
throw new NotImplementedException();
}
return(EmitExpRaw(exp.ConcreteVal, env));
}
private MidElementDecl GetFreq(IResTypeExp type, MidEmitEnv env)
{
if (type is ResFreqQualType)
{
var fqType = (ResFreqQualType)type;
var elementType = (MidElementType)EmitTypeExp(fqType.Freq, env);
return(elementType.Decl);
}
return(null);
}
public MidLocalEmitEnv(
MidEmitEnv parent,
IdentifierFactory identifiers,
MidElementDecl element,
MidExpFactory exps)
: base(parent)
{
_identifiers = identifiers;
_element = element;
_exps = exps;
}
public MidGenericDecl(
IBuilder parent,
Identifier name,
IResGenericDecl resDecl,
MidEmitContext context,
MidEmitEnv env)
: base(parent)
{
_resDecl = resDecl;
_context = context;
_env = env;
}
private MidExp EmitExpImpl(
ResAssignExp resAssign,
MidEmitEnv env)
{
var dest = EmitVal(resAssign.Dest, env);
var src = EmitVal(resAssign.Src, env);
return(new MidAssignExp(
resAssign.Range,
dest,
src));
}
private MidExp EmitExpImpl(IResFieldRef resField, MidEmitEnv env)
{
var resBind = resField.MemberTerm as ResMemberBind;
var obj = EmitPath(resBind.Obj, env);
var container = EmitMemberTerm(resBind.MemberSpec.Container.MemberTerm, env);
var decl = (MidFieldDecl)container.LookupMemberDecl(resBind.Decl);
return(_exps.FieldRef(resField.Range, obj, decl));
}
