public MethodCompiler(TypeDefinitionCompiler parent, JST.NameSupply outerNameSupply, CST.MethodDef methodDef, MethodCompilationMode mode)
{
env = parent.Env;
this.parent = parent;
methEnv = parent.TyconEnv.AddSelfTypeBoundArguments().AddMethod(methodDef).AddSelfMethodBoundArguments();
messageCtxt = CST.MessageContextBuilders.Env(methEnv);
this.mode = mode;
this.outerNameSupply = outerNameSupply;
var common = default(JST.NameSupply);
switch (mode)
{
case MethodCompilationMode.SelfContained:
common = outerNameSupply;
// Will be bound by function passed to root's BindMethod
rootId = common.GenSym();
assemblyId = common.GenSym();
typeDefinitionId = common.GenSym();
break;
case MethodCompilationMode.DirectBind:
common = outerNameSupply.Fork();
// Already bound
rootId = parent.RootId;
assemblyId = parent.AssemblyId;
typeDefinitionId = parent.TypeDefinitionId;
break;
default:
throw new ArgumentOutOfRangeException("mode");
}
nameSupply = common.Fork();
simpNameSupply = common.Fork();
}
public TypeCompiler(TypeDefinitionCompiler parent)
{
// Type compiler is always in context of it's type definition
Env = parent.Env;
Parent = parent;
var typeEnv = parent.TyconEnv.AddSelfTypeBoundArguments();
NameSupply = typeEnv.Type.Arity > 0 ? parent.NameSupply.Fork() : parent.NameSupply;
RootId = parent.RootId;
AssemblyId = parent.AssemblyId;
TypeDefinitionId = parent.TypeDefinitionId;
TypeId = typeEnv.Type.Arity > 0 ? NameSupply.GenSym() : parent.TypeDefinitionId;
TypeCompEnv = TypeCompilerEnvironment.EnterType(Env, NameSupply, RootId, AssemblyId, TypeId, typeEnv, parent.TypeTrace);
}
// ----------------------------------------------------------------------
// Compiling types
// ----------------------------------------------------------------------
private void CompileTypes(Seq <JST.Statement> body)
{
switch (Env.CompilationMode)
{
case CompilationMode.Plain:
case CompilationMode.Collecting:
{
var need = new Map <CST.TypeName, CST.TypeDef>();
foreach (var typeDef in typeDefs)
{
need.Add(typeDef.EffectiveName(Env.Global), typeDef);
}
foreach (var nm in assmEnv.AllTypesInLoadOrder().Where(need.ContainsKey))
{
var compiler = new TypeDefinitionCompiler(this, need[nm]);
compiler.Emit(body);
}
break;
}
case CompilationMode.Traced:
{
var need = new Map <CST.TypeName, TypeTrace>();
foreach (var typeDef in typeDefs)
{
var nm = typeDef.EffectiveName(Env.Global);
var typeTrace = default(TypeTrace);
if (assemblyTrace.TypeMap.TryGetValue(nm, out typeTrace))
{
need.Add(nm, typeTrace);
}
}
foreach (var nm in assmEnv.AllTypesInLoadOrder().Where(need.ContainsKey))
{
var compiler = new TypeDefinitionCompiler(this, need[nm]);
compiler.Emit(body);
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
// ----------------------------------------------------------------------
// Compiling types
// ----------------------------------------------------------------------
private void CompileTypes(Seq<JST.Statement> body)
{
switch (Env.CompilationMode)
{
case CompilationMode.Plain:
case CompilationMode.Collecting:
{
var need = new Map<CST.TypeName, CST.TypeDef>();
foreach (var typeDef in typeDefs)
need.Add(typeDef.EffectiveName(Env.Global), typeDef);
foreach (var nm in assmEnv.AllTypesInLoadOrder().Where(need.ContainsKey))
{
var compiler = new TypeDefinitionCompiler(this, need[nm]);
compiler.Emit(body);
}
break;
}
case CompilationMode.Traced:
{
var need = new Map<CST.TypeName, TypeTrace>();
foreach (var typeDef in typeDefs)
{
var nm = typeDef.EffectiveName(Env.Global);
var typeTrace = default(TypeTrace);
if (assemblyTrace.TypeMap.TryGetValue(nm, out typeTrace))
need.Add(nm, typeTrace);
}
foreach (var nm in assmEnv.AllTypesInLoadOrder().Where(need.ContainsKey))
{
var compiler = new TypeDefinitionCompiler(this, need[nm]);
compiler.Emit(body);
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
