public static void UnpackArray(BooCodeBuilder codeBuilder, Method method, Block block, Expression expression, DeclarationCollection declarations)
{
ILocalEntity local = expression.Entity as ILocalEntity;
if (null == local)
{
local = codeBuilder.DeclareTempLocal(method,
expression.ExpressionType);
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(local),
expression));
}
for (int i = 0; i < declarations.Count; ++i)
{
Declaration declaration = declarations[i];
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(
declaration.Entity),
codeBuilder.CreateSlicing(
codeBuilder.CreateReference(local),
i)));
}
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, Method method)
{
if (null == codeBuilder)
throw new ArgumentNullException("codeBuilder");
if (null == method)
throw new ArgumentNullException("method");
_codeBuilder = codeBuilder;
_method = method;
}
Method CreateFieldAccessor(IField member)
{
BooCodeBuilder builder = _context.CodeBuilder;
Method method = builder.CreateMethod("___" + member.Name, member.Type, TypeMemberModifiers.None);
method.Body.Add(
new ReturnStatement(
builder.CreateReference(member)));
return(method);
}
public BooClassBuilder(string name)
{
if (name == null)
throw new ArgumentNullException("name");
_internalTypeSystemProvider = My<InternalTypeSystemProvider>.Instance;
_codeBuilder = My<BooCodeBuilder>.Instance;
_cd = new ClassDefinition { Name = name, IsSynthetic = true };
EnsureEntityFor(_cd);
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, string name, IType returnType, TypeMemberModifiers modifiers)
{
if (null == codeBuilder)
throw new ArgumentNullException("codeBuilder");
if (null == name)
throw new ArgumentNullException("name");
_codeBuilder = codeBuilder;
_method = _codeBuilder.CreateMethod(name, returnType, modifiers);
}
public AwaitCatchFrame(TypeSystemServices tss, BooCodeBuilder builder, Method currentMethod)
{
pendingCaughtException = builder.DeclareTempLocal(currentMethod, tss.ObjectType);
pendingCatch = builder.DeclareTempLocal(currentMethod, tss.IntType);
handlers = new List <Block>();
_hoistedLocals = new Dictionary <InternalLocal, InternalLocal>();
_orderedHoistedLocals = new List <InternalLocal>();
_currentMethod = currentMethod;
}
public AwaitFinallyFrame(AwaitFinallyFrame parent, HashSet <InternalLabel> labelsOpt, TryStatement TryStatement, BooCodeBuilder builder, int depth)
{
Debug.Assert(parent != null);
Debug.Assert(TryStatement != null);
ParentOpt = parent;
_labelsOpt = labelsOpt;
_tryStatementOpt = TryStatement;
_builder = builder;
_tryDepth = depth;
}
private AsyncExceptionHandlerRewriter(
Method containingMethod,
BooCodeBuilder factory,
AwaitInFinallyAnalysis analysis)
{
_F = factory;
_analysis = analysis;
_containingMethod = containingMethod;
_currentAwaitFinallyFrame = new AwaitFinallyFrame(factory);
_tss = My <TypeSystemServices> .Instance;
}
public static void UnpackExpression(BooCodeBuilder codeBuilder, Method method, Block block, Expression expression, DeclarationCollection declarations)
{
if (expression.ExpressionType.IsArray)
{
UnpackArray(codeBuilder, method, block, expression, declarations);
}
else
{
UnpackEnumerable(codeBuilder, method, block, expression, declarations);
}
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, Method method)
{
if (null == codeBuilder)
{
throw new ArgumentNullException("codeBuilder");
}
if (null == method)
{
throw new ArgumentNullException("method");
}
_codeBuilder = codeBuilder;
_method = method;
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, string name, IType returnType, TypeMemberModifiers modifiers)
{
if (null == codeBuilder)
{
throw new ArgumentNullException("codeBuilder");
}
if (null == name)
{
throw new ArgumentNullException("name");
}
_codeBuilder = codeBuilder;
_method = _codeBuilder.CreateMethod(name, returnType, modifiers);
}
Method CreateFieldSetter(IField member)
{
BooCodeBuilder builder = _context.CodeBuilder;
Method method = builder.CreateMethod("___" + member.Name, _context.TypeSystemServices.VoidType, TypeMemberModifiers.None);
ParameterDeclaration value = builder.CreateParameterDeclaration(1, "value", member.Type);
method.Parameters.Add(value);
method.Body.Add(
builder.CreateFieldAssignment(
LexicalInfo.Empty,
member,
builder.CreateReference(value)));
return(method);
}
public BooClassBuilder(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
_internalTypeSystemProvider = My <InternalTypeSystemProvider> .Instance;
_codeBuilder = My <BooCodeBuilder> .Instance;
_cd = new ClassDefinition {
Name = name, IsSynthetic = true
};
EnsureEntityFor(_cd);
}
public static Expression CreateCallableFromMacroBody(BooCodeBuilder builder, MacroStatement macro)
{
// create closure for macro's body or null
Expression macroBody = new NullLiteralExpression();
if (macro.Block.Statements.Count > 0)
{
var callableExpr = new BlockExpression {
Body = macro.Block
};
callableExpr.Parameters.Add(
new ParameterDeclaration("OutputStream",
builder.CreateTypeReference(typeof(TextWriter))));
macroBody = callableExpr;
}
return(macroBody);
}
public static void UnpackEnumerable(BooCodeBuilder codeBuilder, Method method, Block block, Expression expression, DeclarationCollection declarations)
{
TypeSystemServices tss = codeBuilder.TypeSystemServices;
InternalLocal local = codeBuilder.DeclareTempLocal(method,
tss.IEnumeratorType);
IType expressionType = expression.ExpressionType;
if (expressionType.IsSubclassOf(codeBuilder.TypeSystemServices.IEnumeratorType))
{
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(local),
expression));
}
else
{
if (!expressionType.IsSubclassOf(codeBuilder.TypeSystemServices.IEnumerableType))
{
expression = codeBuilder.CreateMethodInvocation(
RuntimeServices_GetEnumerable, expression);
}
block.Add(
codeBuilder.CreateAssignment(
block.LexicalInfo,
codeBuilder.CreateReference(local),
codeBuilder.CreateMethodInvocation(
expression, IEnumerable_GetEnumerator)));
}
for (int i = 0; i < declarations.Count; ++i)
{
Declaration declaration = declarations[i];
block.Add(
codeBuilder.CreateAssignment(
codeBuilder.CreateReference(declaration.Entity),
codeBuilder.CreateMethodInvocation(RuntimeServices_MoveNext,
codeBuilder.CreateReference(local))));
}
}
public void HoistLocal(InternalLocal local, BooCodeBuilder F)
{
if (!_hoistedLocals.Keys.Any(l => l.Name == local.Name && l.Type == local.Type))
{
_hoistedLocals.Add(local, local);
_orderedHoistedLocals.Add(local);
return;
}
// code uses "await" in two sibling catches with exception filters
// locals with same names and types may cause problems if they are lifted
// and become fields with identical signatures.
// To avoid such problems we will mangle the name of the second local.
// This will only affect debugging of this extremely rare case.
var newLocal = F.DeclareTempLocal(_currentMethod, local.Type);
_hoistedLocals.Add(local, newLocal);
_orderedHoistedLocals.Add(newLocal);
}
Method CreateMethodAccessor(IMethod member)
{
BooCodeBuilder builder = _context.CodeBuilder;
Method method = builder.CreateMethodFromPrototype(LexicalInfo.Empty, member, TypeMemberModifiers.None);
method.Name = "___" + member.Name;
MethodInvocationExpression mie = builder.CreateMethodInvocation(member);
foreach (ParameterDeclaration p in method.Parameters)
{
mie.Arguments.Add(builder.CreateReference(p));
}
if (member.ReturnType == _context.TypeSystemServices.VoidType)
{
method.Body.Add(mie);
}
else
{
method.Body.Add(new ReturnStatement(mie));
}
return(method);
}
public AwaitFinallyFrame(BooCodeBuilder builder)
{
_builder = builder;
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, string name, IType returnType) : this(codeBuilder, name, returnType, TypeMemberModifiers.Public)
{
}
public BooMethodBuilder(BooCodeBuilder codeBuilder, string name, IType returnType) : this(codeBuilder, name, returnType, TypeMemberModifiers.Public)
{
}
private AwaitExpressionSpiller(Method method, TypeSystemServices tss)
{
_F = My <BooCodeBuilder> .Instance;
_currentMethod = method;
_tss = tss;
}
