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);
}
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);
}
}
return new SymbolImplementation(statements, _rootScope);
}
public SymbolImplementation BuildField(FieldSymbol fieldSymbol)
{
_rootScope = new SymbolScope((ISymbolTable)fieldSymbol.Parent);
_currentScope = _rootScope;
Expression initializerExpression;
FieldDeclarationNode fieldDeclarationNode = (FieldDeclarationNode)fieldSymbol.ParseContext;
Debug.Assert(fieldDeclarationNode != null);
VariableInitializerNode initializerNode = (VariableInitializerNode)fieldDeclarationNode.Initializers[0];
if (initializerNode.Value != null) {
ExpressionBuilder expressionBuilder = new ExpressionBuilder(this, fieldSymbol, _errorHandler, _options);
initializerExpression = expressionBuilder.BuildExpression(initializerNode.Value);
if (initializerExpression is MemberExpression) {
initializerExpression =
expressionBuilder.TransformMemberExpression((MemberExpression)initializerExpression);
}
}
else {
object defaultValue = null;
TypeSymbol fieldType = fieldSymbol.AssociatedType;
SymbolSet symbolSet = fieldSymbol.SymbolSet;
if (fieldType.Type == SymbolType.Enumeration) {
// The default for named values is null, so this only applies to
// regular enum types
EnumerationSymbol enumType = (EnumerationSymbol)fieldType;
if (enumType.UseNamedValues == false) {
defaultValue = 0;
}
}
else if ((fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Integer)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedInteger)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Long)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedLong)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Short)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedShort)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Byte)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.SignedByte)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Double)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Single)) ||
(fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Decimal))) {
defaultValue = 0;
}
else if (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Boolean)) {
defaultValue = false;
}
initializerExpression =
new LiteralExpression(symbolSet.ResolveIntrinsicType(IntrinsicType.Object),
defaultValue);
}
List<Statement> statements = new List<Statement>();
statements.Add(new ExpressionStatement(initializerExpression, /* isFragment */ true));
return new SymbolImplementation(statements, null);
}
