public void AddCatch(VariableSymbol exceptionVariable, Statement catchStatement) {
Debug.Assert(_exceptionVariable == null);
Debug.Assert(_catch == null);
_exceptionVariable = exceptionVariable;
_catch = catchStatement;
}
private Statement ProcessVariableDeclarationStatement(VariableDeclarationNode node)
{
VariableDeclarationStatement statement = new VariableDeclarationStatement();
TypeSymbol variableType = _symbolSet.ResolveType(node.Type, _symbolTable, _memberContext);
foreach (VariableInitializerNode initializerNode in node.Initializers) {
string name = initializerNode.Name.Name;
VariableSymbol symbol = new VariableSymbol(name, _memberContext, variableType);
if (initializerNode.Value != null) {
Expression value = _expressionBuilder.BuildExpression(initializerNode.Value);
if (value is MemberExpression) {
value = _expressionBuilder.TransformMemberExpression((MemberExpression)value);
}
symbol.SetValue(value);
}
_symbolTable.AddSymbol(symbol);
statement.AddVariable(symbol);
}
return statement;
}
private Statement ProcessTryCatchFinallyStatement(TryNode node)
{
Debug.Assert(node.CatchClauses.Count < 2);
Debug.Assert((node.CatchClauses.Count == 1) || (node.FinallyClause != null));
TryCatchFinallyStatement statement = new TryCatchFinallyStatement();
Statement body = BuildStatement((StatementNode)node.Body);
statement.AddBody(body);
if (node.CatchClauses.Count == 1) {
CatchNode catchNode = (CatchNode)node.CatchClauses[0];
VariableSymbol exceptionVariableSymbol = null;
if (catchNode.Name != null) {
TypeSymbol exceptionVariableType =
_symbolSet.ResolveType(catchNode.Type, _symbolTable, _memberContext);
Debug.Assert(exceptionVariableType != null);
exceptionVariableSymbol =
new VariableSymbol(catchNode.Name.Name, _memberContext, exceptionVariableType);
}
else {
TypeSymbol exceptionVariableType =
_symbolSet.ResolveIntrinsicType(IntrinsicType.Exception);
Debug.Assert(exceptionVariableType != null);
exceptionVariableSymbol =
new VariableSymbol(_symbolTable.CreateSymbolName("e"), _memberContext, exceptionVariableType);
}
_symbolTable.PushScope();
_symbolTable.AddSymbol(exceptionVariableSymbol);
Statement catchStatement = BuildStatement((StatementNode)catchNode.Body);
statement.AddCatch(exceptionVariableSymbol, catchStatement);
_symbolTable.PopScope();
}
if (node.FinallyClause != null) {
Statement finallyStatement = BuildStatement((StatementNode)node.FinallyClause);
statement.AddFinally(finallyStatement);
}
return statement;
}
private Statement ProcessForeachStatement(ForeachNode node)
{
TypeSymbol type = _symbolSet.ResolveType(node.Type, _symbolTable, _memberContext);
Debug.Assert(type != null);
bool dictionaryContainer = (type.Name == "DictionaryEntry") || (type.Name == "KeyValuePair`2");
Expression collectionExpression = _expressionBuilder.BuildExpression(node.Container);
if (collectionExpression is MemberExpression) {
collectionExpression = _expressionBuilder.TransformMemberExpression((MemberExpression)collectionExpression);
}
ForInStatement statement;
if (dictionaryContainer) {
VariableSymbol dictionaryVariable = null;
if (collectionExpression.Type != ExpressionType.Local) {
string dictionaryVariableName = _symbolTable.CreateSymbolName("dict");
dictionaryVariable = new VariableSymbol(dictionaryVariableName, _memberContext,
collectionExpression.EvaluatedType);
}
statement = new ForInStatement(collectionExpression, dictionaryVariable);
string keyVariableName = _symbolTable.CreateSymbolName("key");
VariableSymbol keyVariable = new VariableSymbol(keyVariableName, _memberContext,
_symbolSet.ResolveIntrinsicType(IntrinsicType.String));
statement.SetLoopVariable(keyVariable);
}
else {
statement = new ForInStatement(collectionExpression);
string enumeratorVariableName = _symbolTable.CreateSymbolName("enum");
VariableSymbol enumVariable = new VariableSymbol(enumeratorVariableName, _memberContext,
_symbolSet.ResolveIntrinsicType(IntrinsicType.IEnumerator));
statement.SetLoopVariable(enumVariable);
}
_symbolTable.PushScope();
VariableSymbol itemVariable = new VariableSymbol(node.Name.Name, _memberContext, type);
_symbolTable.AddSymbol(itemVariable);
statement.SetItemVariable(itemVariable);
Statement body = BuildStatement((StatementNode)node.Body);
statement.AddBody(body);
_symbolTable.PopScope();
return statement;
}
public Expression TransformMemberExpression(MemberExpression expression, bool getOrAdd, bool isEventAddRemove) {
switch (expression.Member.Type) {
case SymbolType.EnumerationField:
if (((EnumerationSymbol)expression.Member.Parent).UseNamedValues) {
EnumerationFieldSymbol field = (EnumerationFieldSymbol)expression.Member;
string fieldName = ((EnumerationSymbol)expression.Member.Parent).CreateNamedValue(field);
return new LiteralExpression(_symbolSet.ResolveIntrinsicType(IntrinsicType.String),
fieldName);
}
else if (((TypeSymbol)expression.Member.Parent).IsApplicationType ||
((EnumerationSymbol)expression.Member.Parent).UseNumericValues) {
// For enum types defined within the same assembly, simply use the literal value.
// Same goes for any enums marked as numeric values
return new LiteralExpression(_symbolSet.ResolveIntrinsicType(IntrinsicType.Integer),
((EnumerationFieldSymbol)expression.Member).Value);
}
else {
// For enum types imported for another assembly
return new EnumerationFieldExpression(expression.ObjectReference,
(EnumerationFieldSymbol)expression.Member);
}
case SymbolType.Field:
if (((FieldSymbol)expression.Member).IsConstant) {
return new LiteralExpression(expression.Member.AssociatedType, ((FieldSymbol)expression.Member).Value);
}
if (expression.ObjectReference is BaseExpression) {
// Create a this expression, because "this" works just as well as base.
// It is explicit, because the base was explicit.
return new FieldExpression(new ThisExpression(_classContext, /* explicitReference */ true),
(FieldSymbol)expression.Member);
}
if (((expression.Member.Visibility & MemberVisibility.Static) != 0) &&
(expression.Member.Parent != expression.ObjectReference.EvaluatedType)) {
// Create a new type expression because a static member
// of the base type is being used.
return new FieldExpression(new TypeExpression((ClassSymbol)expression.Member.Parent, expression.MemberMask),
(FieldSymbol)expression.Member);
}
if ((_symbolContext.Parent.Type == SymbolType.Record) &&
(expression.ObjectReference.Type == ExpressionType.This)) {
// Change "this" references inside struct ctor code to "$o"
VariableSymbol objectVariable = new VariableSymbol("$o", _memberContext, _classContext);
return new FieldExpression(new LocalExpression(objectVariable),
(FieldSymbol)expression.Member);
}
if (((expression.Member.Visibility & MemberVisibility.Static) != 0) &&
(expression.Member.Parent == _symbolSet.ResolveIntrinsicType(IntrinsicType.String)) &&
(String.CompareOrdinal(expression.Member.Name, "Empty") == 0)) {
// Convert String.Empty to literal expression
return new LiteralExpression(expression.Member.AssociatedType, String.Empty);
}
return new FieldExpression(expression.ObjectReference,
(FieldSymbol)expression.Member);
case SymbolType.Property:
return new PropertyExpression(expression.ObjectReference,
(PropertySymbol)expression.Member, getOrAdd);
case SymbolType.Method:
Debug.Assert(getOrAdd);
return new DelegateExpression(expression.ObjectReference,
(MethodSymbol)expression.Member);
case SymbolType.Event:
if (isEventAddRemove) {
return new EventExpression(expression.ObjectReference,
(EventSymbol)expression.Member, getOrAdd);
}
else {
Debug.Assert(((EventSymbol)expression.Member).DefaultImplementation);
// When the field corresponding to an event whose accessors are auto-generated is
// referenced, we need to hunt for a special generated field name (this is the
// field that is added to the class).
string fieldName = "__" + Utility.CreateCamelCaseName(expression.Member.Name);
FieldSymbol fieldSymbol = (FieldSymbol)expression.ObjectReference.EvaluatedType.GetMember(fieldName);
Debug.Assert(fieldSymbol != null);
if (expression.ObjectReference is BaseExpression) {
// Create a this expression, because "this" works just as well as base.
// It is explicit, because the base was explicit.
return new FieldExpression(new ThisExpression(_classContext, /* explicitReference */ true),
fieldSymbol);
}
return new FieldExpression(expression.ObjectReference, fieldSymbol);
}
default:
Debug.Fail("Unexpected member type to transform: " + expression.Member.Type);
break;
}
return expression;
}
public void SetLoopVariable(VariableSymbol variable)
{
Debug.Assert(_loopVariable == null);
_loopVariable = variable;
}
public void AddVariable(VariableSymbol variable) {
_variables.Add(variable);
}
public void SetItemVariable(VariableSymbol variable)
{
Debug.Assert(_itemVariable == null);
_itemVariable = variable;
}
public ForInStatement(Expression collectionExpression, VariableSymbol dictionaryVariable)
: base(StatementType.ForIn)
{
_collectionExpression = collectionExpression;
_dictionaryVariable = dictionaryVariable;
}
public void SetLoopVariable(VariableSymbol variable)
{
Debug.Assert(_loopVariable == null);
_loopVariable = variable;
}
public void SetItemVariable(VariableSymbol variable)
{
Debug.Assert(_itemVariable == null);
_itemVariable = variable;
}
public ForInStatement(Expression collectionExpression, VariableSymbol dictionaryVariable)
: base(StatementType.ForIn)
{
_collectionExpression = collectionExpression;
_dictionaryVariable = dictionaryVariable;
}
