/// <summary>
/// Initializes a new instance of the Interface class.
/// </summary>
/// <param name="proxy">Proxy object for the interface.</param>
/// <param name="name">The name of the interface.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="typeConstraints">The list of type constraints on the class, if any.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
internal Interface(CodeUnitProxy proxy, string name, ICollection<Attribute> attributes, ICollection<TypeParameterConstraintClause> typeConstraints, bool unsafeCode)
: base(proxy, ElementType.Interface, name, attributes, typeConstraints, unsafeCode)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertValidString(name, "name");
Param.Ignore(attributes, typeConstraints, unsafeCode);
}
/// <summary>
/// Initializes a new instance of the Expression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type of the expression.</param>
internal Expression(CodeUnitProxy proxy, int type)
: base(proxy, type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(ExpressionType), this.ExpressionType), "The type is invalid.");
}
/// <summary>
/// Reads a NOT expression.
/// </summary>
/// <param name="parentProxy">Represents the parent item.</param>
/// <returns>Returns the expression.</returns>
private UnaryExpression GetConditionalPreprocessorNotExpression(CodeUnitProxy parentProxy)
{
Param.AssertNotNull(parentProxy, "parentProxy");
this.AdvanceToNextConditionalDirectiveCodeSymbol(parentProxy);
var expressionProxy = new CodeUnitProxy(this.document);
Symbol symbol = this.symbols.Peek(1);
CsLanguageService.Debug.Assert(symbol != null, "The next symbol should not be null");
// Create the token based on the type of the symbol.
var token = new NotOperator(this.document, symbol.Text, symbol.Location, this.symbols.Generated);
expressionProxy.Children.Add(token);
// Advance up to the symbol and add it to the document.
this.symbols.Advance();
// Get the expression after the operator.
Expression expression = this.GetNextConditionalPreprocessorExpression(this.document, expressionProxy, ExpressionPrecedence.Unary);
if (expression == null || expression.Children.Count == 0)
{
throw new SyntaxException(this.document, symbol.LineNumber);
}
// Create and return the expression.
var unaryExpression = new NotExpression(expressionProxy, expression);
parentProxy.Children.Add(unaryExpression);
return(unaryExpression);
}
/// <summary>
/// Initializes a new instance of the Enum 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="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
internal Enum(CodeUnitProxy proxy, string name, ICollection<Attribute> attributes, bool unsafeCode)
: base(proxy, ElementType.Enum, name, attributes, unsafeCode)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertValidString(name, "name");
Param.Ignore(attributes, unsafeCode);
}
/// <summary>
/// Initializes a new instance of the Statement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="type">The type of the statement.</param>
internal Statement(CodeUnitProxy proxy, StatementType type)
: base(proxy, (int)type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(StatementType), this.StatementType), "The type is invalid.");
}
/// <summary>
/// Initializes a new instance of the Struct class.
/// </summary>
/// <param name="proxy">Proxy object for the struct.</param>
/// <param name="name">The name of the struct.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="typeConstraints">The list of type constraints on the class, if any.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
internal Struct(CodeUnitProxy proxy, string name, ICollection <Attribute> attributes, ICollection <TypeParameterConstraintClause> typeConstraints, bool unsafeCode)
: base(proxy, ElementType.Struct, name, attributes, typeConstraints, unsafeCode)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertValidString(name, "name");
Param.Ignore(attributes, typeConstraints, unsafeCode);
}
/// <summary>
/// Reads an expression starting with an unknown word.
/// </summary>
/// <param name="parentProxy">Proxy object for the parent item.</param>
/// <returns>Returns the expression.</returns>
private LiteralExpression GetConditionalPreprocessorConstantExpression(CodeUnitProxy parentProxy)
{
Param.AssertNotNull(parentProxy, "parentProxy");
this.AdvanceToNextConditionalDirectiveCodeSymbol(parentProxy);
var expressionProxy = new CodeUnitProxy(this.document);
// Get the first symbol.
Symbol symbol = this.symbols.Peek(1);
CsLanguageService.Debug.Assert(symbol != null && symbol.SymbolType == SymbolType.Other, "Expected a text symbol");
// Convert the symbol to a token.
this.symbols.Advance();
var literalToken = new LiteralToken(this.document, symbol.Text, symbol.Location, this.symbols.Generated);
expressionProxy.Children.Add(literalToken);
// Create a literal expression from this token.
var literalExpression = new LiteralExpression(expressionProxy, literalToken);
parentProxy.Children.Add(literalExpression);
return(literalExpression);
}
/// <summary>
/// Initializes a new instance of the GenericTypeToken class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
internal GenericTypeToken(CodeUnitProxy proxy)
: base(proxy)
{
Param.AssertGreaterThanOrEqualTo(proxy.Children.Count, 3, "childTokens");
this.IsGeneric = true;
}
/// <summary>
/// Initializes a new instance of the Expression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type of the expression.</param>
internal Expression(CodeUnitProxy proxy, int type)
: base(proxy, type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(ExpressionType), this.ExpressionType), "The type is invalid.");
}
/// <summary>
/// Initializes a new instance of the Enum 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="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
internal Enum(CodeUnitProxy proxy, string name, ICollection <Attribute> attributes, bool unsafeCode)
: base(proxy, ElementType.Enum, name, attributes, unsafeCode)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertValidString(name, "name");
Param.Ignore(attributes, unsafeCode);
}
/// <summary>
/// Initializes a new instance of the GenericTypeToken class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
internal GenericTypeToken(CodeUnitProxy proxy)
: base(proxy)
{
Param.AssertGreaterThanOrEqualTo(proxy.Children.Count, 3, "childTokens");
this.IsGeneric = true;
}
/// <summary>
/// Initializes a new instance of the QueryClause class.
/// </summary>
/// <param name="proxy">Proxy object for the query clause.</param>
/// <param name="type">The type of the clause.</param>
internal QueryClause(CodeUnitProxy proxy, QueryClauseType type)
: base(proxy, (int)type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(QueryClauseType), this.QueryClauseType), "The type is invalid.");
}
/// <summary>
/// Initializes a new instance of the Element class.
/// </summary>
/// <param name="proxy">Proxy object for the element.</param>
/// <param name="type">The element type.</param>
/// <param name="name">The name of this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="unsafeCode">Indicates whether the element is unsafe.</param>
internal Element(
CodeUnitProxy proxy,
int type,
string name,
ICollection <Attribute> attributes,
bool unsafeCode)
: base(proxy, (int)type)
{
Param.Ignore(proxy);
Param.Ignore(type);
Param.AssertNotNull(name, "name");
Param.Ignore(attributes);
Param.Ignore(unsafeCode);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(ElementType), this.ElementType), "The type is invalid.");
this.name.Value = name;
this.attributes.Value = attributes ?? Attribute.EmptyAttributeArray;
CsLanguageService.Debug.Assert(attributes == null || attributes.IsReadOnly, "The attributes collection should be read-only");
this.unsafeCode.Value = unsafeCode;
if (!unsafeCode && this.ContainsModifier(TokenType.Unsafe))
{
this.unsafeCode.Value = true;
}
}
/// <summary>
/// Initializes a new instance of the FixedStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="fixedVariable">The fixed variable.</param>
internal FixedStatement(CodeUnitProxy proxy, VariableDeclarationExpression fixedVariable)
: base(proxy, StatementType.Fixed)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(fixedVariable, "fixedVariable");
this.fixedVariable.Value = fixedVariable;
}
/// <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 LiteralExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="token">The literal token.</param>
internal LiteralExpression(CodeUnitProxy proxy, Token token)
: base(proxy, ExpressionType.Literal)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(token, "token");
this.token.Value = token;
}
/// <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 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 ArgumentList class.
/// </summary>
/// <param name="proxy">The proxy class.</param>
/// <param name="arguments">The collection of arguments within the list.</param>
internal ArgumentList(CodeUnitProxy proxy, IEnumerable<Argument> arguments)
: base(proxy, CodeUnitType.ArgumentList)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(arguments, "arguments");
this.arguments.Value = new List<Argument>(arguments);
}
/// <summary>
/// Initializes a new instance of the StackallocExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The array type.</param>
internal StackallocExpression(CodeUnitProxy proxy, ArrayAccessExpression type)
: base(proxy, ExpressionType.Stackalloc)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(type, "type");
this.type.Value = type;
}
/// <summary>
/// Initializes a new instance of the StackallocExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The array type.</param>
internal StackallocExpression(CodeUnitProxy proxy, ArrayAccessExpression type)
: base(proxy, ExpressionType.Stackalloc)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(type, "type");
this.type.Value = type;
}
/// <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 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 DefaultValueExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type to obtain the default value of.</param>
internal DefaultValueExpression(CodeUnitProxy proxy, LiteralExpression type)
: base(proxy, ExpressionType.DefaultValue)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(type, "type");
this.type.Value = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
}
/// <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 LabelStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="identifier">The label identifier.</param>
internal LabelStatement(CodeUnitProxy proxy, LiteralExpression identifier)
: base(proxy, StatementType.Label)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(identifier, "identifier");
this.identifier.Value = identifier;
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The inner expression.</param>
internal VariableDeclarationStatement(CodeUnitProxy proxy, VariableDeclarationExpression expression)
: base(proxy, StatementType.VariableDeclaration)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <summary>
/// Initializes a new instance of the LabelStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="identifier">The label identifier.</param>
internal LabelStatement(CodeUnitProxy proxy, LiteralExpression identifier)
: base(proxy, StatementType.Label)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(identifier, "identifier");
this.identifier.Value = identifier;
}
/// <summary>
/// Initializes a new instance of the UnsafeStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="body">The body of the try-statement.</param>
internal UnsafeStatement(CodeUnitProxy proxy, BlockStatement body)
: base(proxy, StatementType.Unsafe)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(body, "body");
this.body.Value = body;
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The inner expression.</param>
internal VariableDeclarationStatement(CodeUnitProxy proxy, VariableDeclarationExpression expression)
: base(proxy, StatementType.VariableDeclaration)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <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 ComplexToken class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="tokenType">The type of the token.</param>
internal ComplexToken(CodeUnitProxy proxy, TokenType tokenType)
: base(proxy, tokenType)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(tokenType);
this.IsComplexToken = true;
}
/// <summary>
/// Initializes a new instance of the PreprocessorDirective class.
/// </summary>
/// <param name="proxy">Proxy object for the directive.</param>
/// <param name="preprocessorType">The type of the preprocessor.</param>
internal PreprocessorDirective(CodeUnitProxy proxy, PreprocessorType preprocessorType)
: base(proxy, (int)preprocessorType)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(preprocessorType);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(PreprocessorType), this.PreprocessorType), "The type is invalid.");
}
/// <summary>
/// Initializes a new instance of the PreprocessorDirective class.
/// </summary>
/// <param name="proxy">Proxy object for the directive.</param>
/// <param name="preprocessorType">The type of the preprocessor.</param>
internal PreprocessorDirective(CodeUnitProxy proxy, PreprocessorType preprocessorType)
: base(proxy, (int)preprocessorType)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(preprocessorType);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(PreprocessorType), this.PreprocessorType), "The type is invalid.");
}
/// <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 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 LexicalElement class.
/// </summary>
/// <param name="proxy">The proxy for the element.</param>
/// <param name="lexicalElementType">The lexical element type.</param>
internal LexicalElement(CodeUnitProxy proxy, int lexicalElementType)
: base(proxy, (int)lexicalElementType)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(lexicalElementType);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(LexicalElementType), this.LexicalElementType), "The type is invalid.");
}
/// <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 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 QuerySelectClause class.
/// </summary>
/// <param name="proxy">Proxy object for the clause.</param>
/// <param name="expression">The expression.</param>
internal QuerySelectClause(CodeUnitProxy proxy, Expression expression)
: base(proxy, QueryClauseType.Select)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <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 FixedStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="fixedVariable">The fixed variable.</param>
internal FixedStatement(CodeUnitProxy proxy, VariableDeclarationExpression fixedVariable)
: base(proxy, StatementType.Fixed)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(fixedVariable, "fixedVariable");
this.fixedVariable.Value = fixedVariable;
}
/// <summary>
/// Initializes a new instance of the ConstructorInitializerStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="expression">The expression within this statement.</param>
internal ConstructorInitializerStatement(CodeUnitProxy proxy, MethodInvocationExpression expression)
: base(proxy, StatementType.ConstructorInitializer)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(expression, "expression");
this.expression.Value = expression;
}
/// <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 UncheckedStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="body">The body of the unchecked statement, if any.</param>
internal UncheckedStatement(CodeUnitProxy proxy, BlockStatement body)
: base(proxy, StatementType.Unchecked)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(body, "body");
this.body.Value = body;
}
/// <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 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 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 LiteralExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="token">The literal token.</param>
internal LiteralExpression(CodeUnitProxy proxy, Token token)
: base(proxy, ExpressionType.Literal)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(token, "token");
this.token.Value = token;
}
/// <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 WhileStatement class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="condition">The expression within the while-statement.</param>
internal WhileStatement(CodeUnitProxy proxy, Expression condition)
: base(proxy, StatementType.While)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(condition, "condition");
this.condition.Value = condition;
}
/// <summary>
/// Initializes a new instance of the TypeofExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type literal to get the type of.</param>
internal TypeofExpression(CodeUnitProxy proxy, LiteralExpression type)
: base(proxy, ExpressionType.Typeof)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(type, "type");
this.type.Value = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
}
/// <summary>
/// Initializes a new instance of the ComplexToken class.
/// </summary>
/// <param name="proxy">Proxy object for the statement.</param>
/// <param name="tokenType">The type of the token.</param>
internal ComplexToken(CodeUnitProxy proxy, TokenType tokenType)
: base(proxy, tokenType)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(tokenType);
this.IsComplexToken = true;
}
/// <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 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 MethodInvocationExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="name">The name of the method.</param>
internal MethodInvocationExpression(CodeUnitProxy proxy, Expression name)
: base(proxy, ExpressionType.MethodInvocation)
{
Param.Ignore(proxy);
Param.AssertNotNull(name, "name");
this.name.Value = name;
}
/// <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 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 ObjectInitializerExpression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="initializers">The list of variable initializers within the
/// array initializer expression.</param>
internal ObjectInitializerExpression(CodeUnitProxy proxy, ICollection<EqualsExpression> initializers)
: base(proxy, ExpressionType.ObjectInitializer)
{
Param.AssertNotNull(proxy, "proxy");
Param.AssertNotNull(initializers, "initializers");
this.initializers.Value = initializers;
CsLanguageService.Debug.Assert(initializers.IsReadOnly, "The collection of initializers should be read-only.");
}