/// <summary>
/// Initializes a new instance of the SizeofExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type to get the size of.</param>
internal SizeofExpression(CodeUnitProxy proxy, Expression type)
: base(proxy, ExpressionType.Sizeof)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(type, "type");
this.type.Value = type;
}
/// <summary>
/// Initializes a new instance of the ReturnStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="returnValue">The return value expression, if there is one.</param>
internal ReturnStatement(CodeUnitProxy proxy, Expression returnValue)
: base(proxy, StatementType.Return)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(returnValue);
this.returnValue.Value = returnValue;
}
/// <summary>
/// Initializes a new instance of the IfStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="condition">The expression within the if-statement.</param>
internal IfStatement(CodeUnitProxy proxy, Expression condition)
: base(proxy, StatementType.If)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(condition, "condition");
this.condition.Value = condition;
}
/// <summary>
/// Initializes a new instance of the QueryWhereClause class.
/// </summary>
/// <param name="proxy">Proxy object for the clause.</param>
/// <param name="expression">The expression.</param>
internal QueryWhereClause(CodeUnitProxy proxy, Expression expression)
: base(proxy, QueryClauseType.Where)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <summary>
/// Initializes a new instance of the CheckedExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="internalExpression">The expression wrapped within the checked expression.</param>
internal CheckedExpression(CodeUnitProxy proxy, Expression internalExpression)
: base(proxy, ExpressionType.Checked)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(internalExpression, "internalExpression");
this.internalExpression.Value = internalExpression;
}
/// <summary>
/// Initializes a new instance of the UsingStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="resource">The resource aquisition expression declared in the using statement.</param>
internal UsingStatement(CodeUnitProxy proxy, Expression resource)
: base(proxy, StatementType.Using)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(resource, "resource");
this.resource.Value = resource;
}
/// <summary>
/// Initializes a new instance of the ParenthesizedExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="innerExpression">The expression within the parenthesis.</param>
internal ParenthesizedExpression(CodeUnitProxy proxy, Expression innerExpression)
: base(proxy, ExpressionType.Parenthesized)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(innerExpression, "innerExpression");
this.innerExpression.Value = innerExpression;
}
/// <summary>
/// Initializes a new instance of the LockStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="lockedExpression">The item to lock.</param>
internal LockStatement(CodeUnitProxy proxy, Expression lockedExpression)
: base(proxy, StatementType.Lock)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(lockedExpression, "lockedExpression");
this.lockObject.Value = lockedExpression;
}
/// <summary>
/// Initializes a new instance of the ExpressionStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The expression within this statement.</param>
internal ExpressionStatement(CodeUnitProxy proxy, Expression expression)
: base(proxy, StatementType.Expression)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <summary>
/// Initializes a new instance of the SwitchCaseStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="identifier">The case label identifier.</param>
internal SwitchCaseStatement(CodeUnitProxy proxy, Expression identifier)
: base(proxy, StatementType.SwitchCase)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(identifier, "identifier");
this.identifier.Value = identifier;
}
/// <summary>
/// Initializes a new instance of the ElseStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="condition">The expression within the if portion of this
/// else-statement, if any.</param>
internal ElseStatement(CodeUnitProxy proxy, Expression condition)
: base(proxy, StatementType.Else)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(condition);
this.condition.Value = condition;
}
/// <summary>
/// Initializes a new instance of the ArrayAccessExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="array">Represents the item being indexed.</param>
internal ArrayAccessExpression(CodeUnitProxy proxy, Expression array)
: base(proxy, ExpressionType.ArrayAccess)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(array, "array");
this.array.Value = array;
}
/// <summary>
/// Initializes a new instance of the ThrowStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="thrownExpression">The expression being thrown, if any.</param>
internal ThrowStatement(CodeUnitProxy proxy, Expression thrownExpression)
: base(proxy, StatementType.Throw)
{
Param.Ignore(proxy);
Param.Ignore(thrownExpression);
this.thrownExpression.Value = thrownExpression;
}
/// <summary>
/// Initializes a new instance of the QueryGroupClause class.
/// </summary>
/// <param name="proxy">Proxy object for the clause.</param>
/// <param name="expression">The expression.</param>
/// <param name="groupByExpression">The group by expression.</param>
internal QueryGroupClause(CodeUnitProxy proxy, Expression expression, Expression groupByExpression)
: base(proxy, QueryClauseType.Group)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
Param.AssertNotNull(groupByExpression, "groupByExpression");
this.groupByExpression.Value = groupByExpression;
}
/// <summary>
/// Initializes a new instance of the EnumItem class.
/// </summary>
/// <param name="proxy">Proxy object for the enum.</param>
/// <param name="name">The name of the enum.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="initialization">The initialization expression, if there is one.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
internal EnumItem(CodeUnitProxy proxy, string name, ICollection<Attribute> attributes, Expression initialization, bool unsafeCode)
: base(proxy, ElementType.EnumItem, name, attributes, unsafeCode)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertValidString(name, "name");
Param.Ignore(attributes, initialization, unsafeCode);
this.initialization.Value = initialization;
}
/// <summary>
/// Initializes a new instance of the AsExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="value">The value to convert.</param>
/// <param name="type">The type of the conversion.</param>
internal AsExpression(CodeUnitProxy proxy, Expression value, LiteralExpression type)
: base(proxy, ExpressionType.As)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(value, "value");
Param.AssertNotNull(type, "type");
this.value.Value = value;
this.type.Value = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
}
/// <summary>
/// Initializes a new instance of the VariableDeclaratorExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="identifier">The identifier name of the variable.</param>
/// <param name="initializer">The initialization expression for the variable.</param>
internal VariableDeclaratorExpression(CodeUnitProxy proxy, LiteralExpression identifier, Expression initializer)
: base(proxy, ExpressionType.VariableDeclarator)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(identifier, "identifier");
Param.Ignore(initializer);
this.identifier.Value = identifier;
this.initializer.Value = initializer;
}
/// <summary>
/// Initializes a new instance of the AttributeExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="target">The attribute target, if any.</param>
/// <param name="initialization">The attribute initialization call.</param>
internal AttributeExpression(CodeUnitProxy proxy, LiteralExpression target, Expression initialization)
: base(proxy, ExpressionType.Attribute)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(target);
Param.AssertNotNull(initialization, "initialization");
this.target.Value = target;
this.initialization.Value = initialization;
}
/// <summary>
/// Initializes a new instance of the DoWhileStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="condition">The expression within the while statement.</param>
/// <param name="body">The body of the do-while-statement.</param>
internal DoWhileStatement(CodeUnitProxy proxy, Expression condition, Statement body)
: base(proxy, StatementType.DoWhile)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(condition, "condition");
Param.AssertNotNull(body, "body");
this.condition.Value = condition;
this.body.Value = body;
}
/// <summary>
/// Initializes a new instance of the ForeachStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="iterationVariable">The iteration variable declared in foreach statement declaration.</param>
/// <param name="collection">The enumerable expression being iterated over.</param>
internal ForeachStatement(CodeUnitProxy proxy, VariableDeclarationExpression iterationVariable, Expression collection)
: base(proxy, StatementType.Foreach)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(iterationVariable, "iterationVariable");
Param.AssertNotNull(collection, "collection");
this.iterationVariable.Value = iterationVariable;
this.collection.Value = collection;
}
/// <summary>
/// Initializes a new instance of the CastExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The cast type.</param>
/// <param name="castedExpression">The expression being casted.</param>
internal CastExpression(CodeUnitProxy proxy, LiteralExpression type, Expression castedExpression)
: base(proxy, ExpressionType.Cast)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(type, "type");
Param.AssertNotNull(castedExpression, "castedExpression");
this.type.Value = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
this.castedExpression.Value = castedExpression;
}
/// <summary>
/// Initializes a new instance of the Argument class.
/// </summary>
/// <param name="proxy">The proxy class.</param>
/// <param name="modifiers">The parameter modifiers.</param>
/// <param name="argumentExpression">The argument expression.</param>
internal Argument(CodeUnitProxy proxy, ParameterModifiers modifiers, Expression argumentExpression)
: base(proxy, CodeUnitType.Argument)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(modifiers, "modifiers");
Param.AssertNotNull(argumentExpression, "argumentExpression");
this.modifiers.Value = modifiers;
this.argumentExpression.Value = argumentExpression;
}
/// <summary>
/// Initializes a new instance of the NullCoalescingExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="leftHandSide">The left hand side of the expression.</param>
/// <param name="rightHandSide">The right hand side of the expression.</param>
internal NullCoalescingExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
: base(proxy, ExpressionType.NullCoalescing)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(leftHandSide, "leftHandSide");
Param.AssertNotNull(rightHandSide, "rightHandSide");
this.leftHandSide.Value = leftHandSide;
this.rightHandSide.Value = rightHandSide;
}
/// <summary>
/// Initializes a new instance of the UnsafeAccessExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type of operation being performed.</param>
/// <param name="value">The value the operator is being applied to.</param>
internal UnsafeAccessExpression(CodeUnitProxy proxy, UnsafeAccessExpressionType type, Expression value)
: base(proxy, (int)type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
Param.AssertNotNull(value, "value");
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(UnsafeAccessExpressionType), this.UnsafeAccessExpressionType), "The type is invalid.");
this.value.Value = value;
}
/// <summary>
/// Initializes a new instance of the ConditionalExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="condition">The condition being evaluated.</param>
/// <param name="trueValue">The expression that is evaluated if the condition is true.</param>
/// <param name="falseValue">The expression that is evaluated if the condition is false.</param>
internal ConditionalExpression(
CodeUnitProxy proxy, Expression condition, Expression trueValue, Expression falseValue)
: base(proxy, ExpressionType.Conditional)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(condition, "condition");
Param.AssertNotNull(trueValue, "trueValue");
Param.AssertNotNull(falseValue, "falseValue");
this.condition.Value = condition;
this.trueValue.Value = trueValue;
this.falseValue.Value = falseValue;
}
/// <summary>
/// Initializes a new instance of the ChildAccessExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type of operation being performed.</param>
/// <param name="leftHandSide">The left side of the operation.</param>
/// <param name="rightHandSide">The member being accessed.</param>
internal ChildAccessExpression(
CodeUnitProxy proxy,
ExpressionType type,
Expression leftHandSide,
LiteralExpression rightHandSide)
: base(proxy, (int)type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
Param.AssertNotNull(leftHandSide, "leftHandSide");
Param.AssertNotNull(rightHandSide, "rightHandSide");
this.leftHandSide.Value = leftHandSide;
this.rightHandSide.Value = rightHandSide;
}
/// <summary>
/// Initializes a new instance of the CatchStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="tryStatement">The try-statement that this catch-statement is attached to.</param>
/// <param name="classExpression">The inner expression.</param>
/// <param name="body">The body of the catch-statement.</param>
internal CatchStatement(
CodeUnitProxy proxy,
TryStatement tryStatement,
Expression classExpression,
BlockStatement body)
: base(proxy, StatementType.Catch)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(tryStatement, "tryStatement");
Param.Ignore(classExpression);
Param.AssertNotNull(body, "body");
this.tryStatement.Value = tryStatement;
this.catchExpression.Value = classExpression;
this.body.Value = body;
}
/// <summary>
/// Initializes a new instance of the QueryJoinClause class.
/// </summary>
/// <param name="proxy">Proxy object for the clause.</param>
/// <param name="inExpression">The expression after the 'in' keyword.</param>
/// <param name="onKeyExpression">The expression after the 'on' keyword.</param>
/// <param name="equalsKeyExpression">The expression after the 'equals' keyword.</param>
internal QueryJoinClause(
CodeUnitProxy proxy,
Expression inExpression,
Expression onKeyExpression,
Expression equalsKeyExpression)
: base(proxy, QueryClauseType.Join)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(inExpression, "inExpression");
Param.AssertNotNull(onKeyExpression, "onKeyExpression");
Param.AssertNotNull(equalsKeyExpression, "equalsKeyExpression");
this.inExpression.Value = inExpression;
this.onKeyExpression.Value = onKeyExpression;
this.equalsKeyExpression.Value = equalsKeyExpression;
}
/// <summary>
/// Initializes a new instance of the AssignmentExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type of operation being performed.</param>
/// <param name="leftHandSide">The left hand side of the expression.</param>
/// <param name="rightHandSide">The right hand side of the expression.</param>
internal AssignmentExpression(
CodeUnitProxy proxy,
AssignmentExpressionType type,
Expression leftHandSide,
Expression rightHandSide)
: base(proxy, (int)type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
Param.AssertNotNull(leftHandSide, "leftHandSide");
Param.AssertNotNull(rightHandSide, "rightHandSide");
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(AssignmentExpressionType), this.AssignmentExpressionType), "The type is invalid.");
this.leftHandSide.Value = leftHandSide;
this.rightHandSide.Value = rightHandSide;
}
/// <summary>
/// Initializes a new instance of the SwitchStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="switchExpression">The expression to switch off of.</param>
/// <param name="caseStatements">The list of case statements under the switch statement.</param>
/// <param name="defaultStatement">The default statement under the switch statement.</param>
internal SwitchStatement(
CodeUnitProxy proxy,
Expression switchExpression,
ICollection<SwitchCaseStatement> caseStatements,
SwitchDefaultStatement defaultStatement)
: base(proxy, StatementType.Switch)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(switchExpression, "switchExpression");
Param.AssertNotNull(caseStatements, "caseStatements");
Param.Ignore(defaultStatement);
this.switchExpression.Value = switchExpression;
this.caseStatements.Value = caseStatements;
this.defaultStatement.Value = defaultStatement;
CsLanguageService.Debug.Assert(caseStatements.IsReadOnly, "The collection of case statements should be read-only.");
}
