public StatementBuilder(ILocalSymbolTable symbolTable, CodeMemberSymbol memberContext, IErrorHandler errorHandler, CompilerOptions options)
{
_symbolTable = symbolTable;
_memberContext = memberContext;
_symbolSet = memberContext.SymbolSet;
_errorHandler = errorHandler;
_expressionBuilder = new ExpressionBuilder(symbolTable, memberContext, errorHandler, options);
}
public AnonymousMethodSymbol(CodeMemberSymbol containingMember, ISymbolTable stackContext,
TypeSymbol returnType, bool isStatic)
: base(SymbolType.AnonymousMethod, /* name */ string.Empty, (TypeSymbol)containingMember.Parent,
returnType)
{
SetVisibility(isStatic ? MemberVisibility.Public | MemberVisibility.Static : MemberVisibility.Public);
ContainingMember = containingMember;
StackContext = stackContext;
ContainingMember.AddAnonymousMethod(this);
}
private static void GenerateImplementationScript(ScriptGenerator generator, MemberSymbol symbol, SymbolImplementation implementation)
{
generator.StartImplementation(implementation);
try {
bool generateThisCacheStatement = false;
if ((symbol.Visibility & MemberVisibility.Static) == 0)
{
CodeMemberSymbol codeMemberSymbol = symbol as CodeMemberSymbol;
if ((codeMemberSymbol != null) && (codeMemberSymbol.AnonymousMethods != null))
{
foreach (AnonymousMethodSymbol anonymousMethod in codeMemberSymbol.AnonymousMethods)
{
if ((anonymousMethod.Visibility & MemberVisibility.Static) == 0)
{
generateThisCacheStatement = true;
break;
}
}
}
}
if (generateThisCacheStatement)
{
ScriptTextWriter writer = generator.Writer;
writer.WriteLine("var $this = this;");
writer.WriteLine();
}
foreach (Statement statement in implementation.Statements)
{
StatementGenerator.GenerateStatement(generator, symbol, statement);
}
}
finally {
generator.EndImplementation();
}
}
private SymbolImplementation BuildImplementation(ISymbolTable symbolTable, CodeMemberSymbol symbolContext,
BlockStatementNode implementationNode, bool addAllParameters)
{
rootScope = new SymbolScope(symbolTable);
currentScope = rootScope;
List <Statement> statements = new List <Statement>();
StatementBuilder statementBuilder = new StatementBuilder(this, symbolContext, errorHandler, options);
if (symbolContext.Parameters != null)
{
int parameterCount = symbolContext.Parameters.Count;
if (addAllParameters == false)
{
// For property getters (including indexers), we don't add the last parameter,
// which happens to be the "value" parameter, which only makes sense
// for the setter.
parameterCount--;
}
for (int paramIndex = 0; paramIndex < parameterCount; paramIndex++)
{
currentScope.AddSymbol(symbolContext.Parameters[paramIndex]);
}
}
if (symbolContext.Type == SymbolType.Constructor &&
(((ConstructorSymbol)symbolContext).Visibility & MemberVisibility.Static) == 0)
{
Debug.Assert(symbolContext.Parent is ClassSymbol);
if (((ClassSymbol)symbolContext.Parent).BaseClass != null)
{
BaseInitializerExpression baseExpr = new BaseInitializerExpression();
ConstructorDeclarationNode ctorNode = (ConstructorDeclarationNode)symbolContext.ParseContext;
if (ctorNode.BaseArguments != null)
{
ExpressionBuilder expressionBuilder =
new ExpressionBuilder(this, symbolContext, errorHandler, options);
Debug.Assert(ctorNode.BaseArguments is ExpressionListNode);
ICollection <Expression> args =
expressionBuilder.BuildExpressionList((ExpressionListNode)ctorNode.BaseArguments);
foreach (Expression paramExpr in args)
{
baseExpr.AddParameterValue(paramExpr);
}
}
statements.Add(new ExpressionStatement(baseExpr));
}
}
foreach (StatementNode statementNode in implementationNode.Statements)
{
Statement statement = statementBuilder.BuildStatement(statementNode);
if (statement != null)
{
statements.Add(statement);
}
}
string thisIdentifier = "this";
if (symbolContext.Type == SymbolType.AnonymousMethod)
{
thisIdentifier = "$this";
}
return(new SymbolImplementation(statements, rootScope, thisIdentifier));
}
