/// <summary>
/// Initializes a new instance of the IsExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="leftSideExpression">
/// The left hand side of the expression.
/// </param>
/// <param name="rightSideExpression">
/// The right hand side of the expression.
/// </param>
/// <param name="matchVariable">
/// The variable declared as part of pattern match of the expression.
/// </param>
internal IsExpression(CsTokenList tokens, Expression leftSideExpression, Expression rightSideExpression, Expression matchVariable)
: base(ExpressionType.Is, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(leftSideExpression, "leftSideExpression");
Param.AssertNotNull(rightSideExpression, "rightSideExpression");
Param.Ignore(matchVariable);
this.leftHandSideExpression = leftSideExpression;
this.rightHandSideExpression = rightSideExpression;
this.matchVariable = matchVariable;
// Extract the type being compared to, if possible.
LiteralExpression le = this.rightHandSideExpression as LiteralExpression;
if (le != null)
{
this.type = CodeParser.TryExtractTypeTokenFromLiteralExpression(le);
}
this.AddExpression(this.leftHandSideExpression);
this.AddExpression(this.rightHandSideExpression);
if (this.matchVariable != null)
{
this.AddExpression(this.matchVariable);
}
}
/// <summary>
/// Initializes a new instance of the Parameter class.
/// </summary>
/// <param name="type">
/// The type of the parameter.
/// </param>
/// <param name="name">
/// The name of the parameter.
/// </param>
/// <param name="parent">
/// The parent of the parameter.
/// </param>
/// <param name="modifiers">
/// Modifiers applied to this parameter.
/// </param>
/// <param name="defaultArgument">
/// The optional default argument for the parameter.
/// </param>
/// <param name="location">
/// The location of the parameter in the code.
/// </param>
/// <param name="tokens">
/// The tokens that form the parameter.
/// </param>
/// <param name="generated">
/// Indicates whether the parameter is located within a block of generated code.
/// </param>
internal Parameter(
TypeToken type,
string name,
Reference <ICodePart> parent,
ParameterModifiers modifiers,
Expression defaultArgument,
CodeLocation location,
CsTokenList tokens,
bool generated)
{
Param.Ignore(type);
Param.AssertValidString(name, "name");
Param.AssertNotNull(parent, "parent");
Param.Ignore(modifiers);
Param.Ignore(defaultArgument);
Param.AssertNotNull(location, "location");
Param.Ignore(tokens);
Param.Ignore(generated);
this.type = type;
this.name = CodeLexer.DecodeEscapedText(name, true);
this.parent = parent;
this.modifiers = modifiers;
this.defaultArgument = defaultArgument;
this.location = location;
this.tokens = tokens;
this.generated = generated;
}
/// <summary>
/// Initializes a new instance of the LocalFunctionStatement class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the statement.
/// </param>
/// <param name="returnType">
/// The return type of this local function.
/// </param>
/// <param name="returnTypeIsRef">
/// The return type of this local function is ref.
/// </param>
/// <param name="identifier">
/// The identifier of this local function.
/// </param>
/// <param name="parameters">
/// The parameter information of this local function.
/// </param>
/// <param name="typeConstraints">
/// The list of type constraints on the element.
/// </param>
private LocalFunctionStatement(
CsTokenList tokens,
TypeToken returnType,
bool returnTypeIsRef,
LiteralExpression identifier,
IList <Parameter> parameters,
ICollection <TypeParameterConstraintClause> typeConstraints)
: base(StatementType.LocalFunction, tokens)
{
Param.AssertNotNull(returnType, nameof(returnType));
Param.Ignore(returnTypeIsRef);
Param.AssertNotNull(identifier, nameof(identifier));
Param.AssertNotNull(parameters, nameof(parameters));
Param.Ignore(typeConstraints);
this.returnType = returnType;
this.returnTypeIsRef = returnTypeIsRef;
this.identifier = identifier;
this.parameters = parameters;
this.typeConstraints = typeConstraints;
this.AddExpression(this.identifier);
// Set the parent of the type constraint clauses.
if (typeConstraints != null)
{
foreach (TypeParameterConstraintClause constraint in typeConstraints)
{
constraint.ParentElement = this;
}
}
}
/// <summary>
/// Checks the placement and formatting of parameters to a method invocation or a method declaration.
/// </summary>
/// <param name="element">
/// The element.
/// </param>
/// <param name="parameterListTokens">
/// The tokens that form the parameter list.
/// </param>
/// <param name="methodArguments">
/// The arguments or parameters to the method.
/// </param>
/// <param name="methodStartLineNumber">
/// The line number on which the method begins.
/// </param>
/// <param name="openBracketType">
/// The type of the parameter list opening bracket.
/// </param>
/// <param name="closeBracketType">
/// The type of the parameter list closing bracket.
/// </param>
/// <param name="friendlyTypeText">
/// The text to use for violations.
/// </param>
private void CheckParameters(
CsElement element,
CsTokenList parameterListTokens,
IArgumentList methodArguments,
int methodStartLineNumber,
CsTokenType openBracketType,
CsTokenType closeBracketType,
string friendlyTypeText)
{
Param.AssertNotNull(element, "element");
Param.AssertNotNull(parameterListTokens, "parameterListTokens");
Param.AssertNotNull(methodArguments, "methodArguments");
Param.AssertGreaterThanZero(methodStartLineNumber, "methodStartLineNumber");
Param.Ignore(openBracketType);
Param.Ignore(closeBracketType);
Node <CsToken> openingBracketNode = this.CheckMethodOpeningBracket(element, parameterListTokens, openBracketType, friendlyTypeText);
if (openingBracketNode != null)
{
this.CheckMethodClosingBracket(element, parameterListTokens, openingBracketNode, closeBracketType, methodArguments);
if (methodArguments.Count > 0)
{
this.CheckMethodArgumentList(element, methodArguments, openingBracketNode, methodStartLineNumber, friendlyTypeText);
}
}
}
/// <summary>
/// Initializes a new instance of the SwitchStatement class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the statement.
/// </param>
/// <param name="switchItem">
/// 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(CsTokenList tokens, Expression switchItem, ICollection <SwitchCaseStatement> caseStatements, SwitchDefaultStatement defaultStatement)
: base(StatementType.Switch, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(switchItem, "switchItem");
Param.AssertNotNull(caseStatements, "caseStatements");
Param.Ignore(defaultStatement);
this.switchItem = switchItem;
this.caseStatements = caseStatements;
this.defaultStatement = defaultStatement;
Debug.Assert(caseStatements.IsReadOnly, "The collection of case statements should be read-only.");
this.AddExpression(switchItem);
foreach (Statement statement in caseStatements)
{
this.AddStatement(statement);
}
if (defaultStatement != null)
{
this.AddStatement(defaultStatement);
}
}
/// <summary>
/// Initializes a new instance of the Argument class.
/// </summary>
/// <param name="name">
/// The optional name of the argument.
/// </param>
/// <param name="modifiers">
/// Modifiers applied to this argument.
/// </param>
/// <param name="argumentExpression">
/// The expression that forms the body of the argument.
/// </param>
/// <param name="location">
/// The location of the argument in the code.
/// </param>
/// <param name="parent">
/// The parent code part.
/// </param>
/// <param name="tokens">
/// The tokens that form the argument.
/// </param>
/// <param name="generated">
/// Indicates whether the argument is located within a block of generated code.
/// </param>
internal Argument(
CsToken name,
ParameterModifiers modifiers,
Expression argumentExpression,
CodeLocation location,
Reference <ICodePart> parent,
CsTokenList tokens,
bool generated)
{
Param.Ignore(name);
Param.Ignore(modifiers);
Param.AssertNotNull(argumentExpression, "argumentExpression");
Param.AssertNotNull(location, "location");
Param.AssertNotNull(parent, "parent");
Param.Ignore(tokens);
Param.Ignore(generated);
this.name = name;
this.modifiers = modifiers;
this.argumentExpression = argumentExpression;
this.location = location;
this.parent = parent;
this.tokens = tokens;
this.generated = generated;
}
/// <summary>
/// Determines whether the token list contains the given strings, skipping whitespace tokens and
/// comments.
/// </summary>
/// <param name="comparisonType">
/// The string comparison type to use.
/// </param>
/// <param name="values">
/// The collection of strings to match against.
/// </param>
/// <returns>
/// Returns true if the tokens match the collection of strings.
/// </returns>
public bool MatchTokens(StringComparison comparisonType, params string[] values)
{
Param.RequireNotNull(values, "values");
Param.Ignore(comparisonType);
return(CsTokenList.MatchTokens(comparisonType, this.First, values));
}
/// <summary>
/// Determines whether the given token list contains the given strings, skipping whitespace tokens and
/// comments.
/// </summary>
/// <param name="start">
/// Begins matching the given strings with this token.
/// </param>
/// <param name="values">
/// The collection of strings to match against.
/// </param>
/// <returns>
/// Returns true if the tokens match the collection of strings.
/// </returns>
public static bool MatchTokens(Node <CsToken> start, params string[] values)
{
Param.RequireNotNull(start, "start");
Param.RequireNotNull(values, "values");
return(CsTokenList.MatchTokens(StringComparison.Ordinal, start, values));
}
/// <summary>
/// Initializes a new instance of the CollectionInitializerExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="initializers">
/// The list of variable initializers within the
/// array initializer expression.
/// </param>
internal CollectionInitializerExpression(CsTokenList tokens, IEnumerable <Expression> initializers)
: base(ExpressionType.CollectionInitializer, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(initializers, "initializers");
this.AddExpressions(initializers);
}
/// <summary>
/// Gets the tokens forming the parameter list for a method declaration.
/// </summary>
/// <param name="tokens">
/// The tokens forming the method declaration.
/// </param>
/// <param name="openBracketType">
/// The type of the opening bracket.
/// </param>
/// <param name="closeBracketType">
/// The type of the closing bracket.
/// </param>
/// <returns>
/// Returns the parameter list or null if it cannot be found.
/// </returns>
private static CsTokenList GetParameterListTokens(CsTokenList tokens, CsTokenType openBracketType, CsTokenType closeBracketType)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(openBracketType);
Param.Ignore(closeBracketType);
return(GetArgumentListTokens(tokens, tokens.First, openBracketType, closeBracketType));
}
/// <summary>
/// Initializes a new instance of the NameofExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="name">
/// The type literal to get the name of.
/// </param>
internal NameofExpression(CsTokenList tokens, LiteralExpression name)
: base(ExpressionType.NameOf, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(name, "name");
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(name);
this.AddExpression(name);
}
/// <summary>
/// Initializes a new instance of the IfStatement class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the statement.
/// </param>
/// <param name="conditionExpression">
/// The expression within the if-statement.
/// </param>
internal IfStatement(CsTokenList tokens, Expression conditionExpression)
: base(StatementType.If, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(conditionExpression, "conditionExpression");
this.conditionExpression = conditionExpression;
this.AddExpression(conditionExpression);
}
/// <summary>
/// Initializes a new instance of the StackallocExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="type">
/// The array type.
/// </param>
internal StackallocExpression(CsTokenList tokens, ArrayAccessExpression type)
: base(ExpressionType.Stackalloc, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
this.type = type;
this.AddExpression(type);
}
/// <summary>
/// Initializes a new instance of the TypeofExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="type">
/// The type literal to get the type of.
/// </param>
internal TypeofExpression(CsTokenList tokens, LiteralExpression type)
: base(ExpressionType.Typeof, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
this.AddExpression(type);
}
/// <summary>
/// Initializes a new instance of the SizeofExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="type">
/// The type to get the size of.
/// </param>
internal SizeofExpression(CsTokenList tokens, Expression type)
: base(ExpressionType.Sizeof, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
this.type = type;
this.AddExpression(type);
}
/// <summary>
/// Initializes a new instance of the FileHeader class.
/// </summary>
/// <param name="headerText">
/// The header text.
/// </param>
/// <param name="tokens">
/// The collection of tokens in the header.
/// </param>
/// <param name="parent">
/// The parent of the header.
/// </param>
internal FileHeader(string headerText, CsTokenList tokens, Reference <ICodePart> parent)
{
Param.AssertNotNull(headerText, "headerText");
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(parent, "parent");
this.headerText = headerText;
this.tokens = tokens;
this.parent = parent;
this.location = this.tokens.First != null?CsToken.JoinLocations(this.tokens.First, this.tokens.Last) : CodeLocation.Empty;
// Attempt to load this into an Xml document.
try
{
if (this.headerText.Length > 0)
{
this.headerXml = string.Format(CultureInfo.InvariantCulture, "<root>{0}</root>", HtmlEncode(this.headerText));
XmlDocument doc = new XmlDocument();
doc.LoadXml(this.headerXml);
// Check whether the header has the autogenerated tag.
if (doc.DocumentElement != null)
{
XmlNode node = doc.DocumentElement["autogenerated"];
if (node != null)
{
// Set this as generated code.
this.generated = true;
}
else
{
node = doc.DocumentElement["auto-generated"];
if (node != null)
{
// Set this as generated code.
this.generated = true;
}
}
StringCollection unstyledElements = new StringCollection();
unstyledElements.AddRange(new[] { "unstyled", "stylecopoff", "nostyle" });
XmlNodeList childNodes = doc.DocumentElement.ChildNodes;
if (childNodes.Cast <XmlNode>().Any(xmlNode => unstyledElements.Contains(xmlNode.Name.ToLowerInvariant())))
{
this.UnStyled = true;
}
}
}
}
catch (XmlException)
{
}
}
/// <summary>
/// Checks a type to determine whether it should use one of the built-in types.
/// </summary>
/// <param name="type">
/// The type to check.
/// </param>
/// <param name="document">
/// The parent document.
/// </param>
private void CheckBuiltInType(Node <CsToken> type, CsDocument document)
{
Param.AssertNotNull(type, "type");
Param.AssertNotNull(document, "document");
Debug.Assert(type.Value is TypeToken, "The type must be a TypeToken");
TypeToken typeToken = (TypeToken)type.Value;
if (type.Value.CsTokenClass != CsTokenClass.GenericType)
{
for (int i = 0; i < this.builtInTypes.Length; ++i)
{
string[] builtInType = this.builtInTypes[i];
if (CsTokenList.MatchTokens(typeToken.ChildTokens.First, builtInType[0]) ||
CsTokenList.MatchTokens(typeToken.ChildTokens.First, "System", ".", builtInType[0]))
{
// If the previous token is an equals sign, then this is a using alias directive. For example:
// using SomeAlias = System.String;
// If the previous token is the 'static' keyword, then this is a using static directive. For example:
// using static System.String;
bool shouldBuiltInTypeAliasBeUsed = true;
for (Node <CsToken> previous = type.Previous; previous != null; previous = previous.Previous)
{
if (previous.Value.CsTokenType != CsTokenType.EndOfLine && previous.Value.CsTokenType != CsTokenType.MultiLineComment &&
previous.Value.CsTokenType != CsTokenType.SingleLineComment && previous.Value.CsTokenType != CsTokenType.WhiteSpace)
{
if (previous.Value.Text == "=" || previous.Value.Text == "static")
{
shouldBuiltInTypeAliasBeUsed = false;
}
break;
}
}
if (shouldBuiltInTypeAliasBeUsed)
{
this.AddViolation(
typeToken.FindParentElement(), typeToken.LineNumber, Rules.UseBuiltInTypeAlias, builtInType[2], builtInType[0], builtInType[1]);
}
break;
}
}
}
for (Node <CsToken> childToken = typeToken.ChildTokens.First; childToken != null; childToken = childToken.Next)
{
if (childToken.Value.CsTokenClass == CsTokenClass.Type || childToken.Value.CsTokenClass == CsTokenClass.GenericType)
{
this.CheckBuiltInType(childToken, document);
}
}
}
/// <summary>
/// Reads an expression wrapped in parenthesis.
/// </summary>
/// <param name="sourceCode">
/// The source code containing the expression.
/// </param>
/// <param name="parentReference">
/// The parent code part.
/// </param>
/// <returns>
/// Returns the expression.
/// </returns>
private ParenthesizedExpression GetConditionalPreprocessorParenthesizedExpression(SourceCode sourceCode, Reference <ICodePart> parentReference)
{
Param.AssertNotNull(sourceCode, "sourceCode");
Param.AssertNotNull(parentReference, "parentReference");
// Get the opening parenthesis.
this.AdvanceToNextConditionalDirectiveCodeSymbol(parentReference);
Symbol firstSymbol = this.symbols.Peek(1);
if (firstSymbol == null || firstSymbol.SymbolType != SymbolType.OpenParenthesis)
{
throw new SyntaxException(sourceCode, firstSymbol.LineNumber);
}
Reference <ICodePart> expressionReference = new Reference <ICodePart>();
this.symbols.Advance();
Bracket openParenthesis = new Bracket(firstSymbol.Text, CsTokenType.OpenParenthesis, firstSymbol.Location, expressionReference, this.symbols.Generated);
Node <CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);
// Get the inner expression.
Expression innerExpression = this.GetNextConditionalPreprocessorExpression(sourceCode, ExpressionPrecedence.None);
if (innerExpression == null)
{
throw new SyntaxException(sourceCode, firstSymbol.LineNumber);
}
// Get the closing parenthesis.
this.AdvanceToNextConditionalDirectiveCodeSymbol(expressionReference);
Symbol symbol = this.symbols.Peek(1);
if (symbol == null || symbol.SymbolType != SymbolType.CloseParenthesis)
{
throw new SyntaxException(sourceCode, firstSymbol.LineNumber);
}
this.symbols.Advance();
Bracket closeParenthesis = new Bracket(symbol.Text, CsTokenType.CloseParenthesis, symbol.Location, expressionReference, this.symbols.Generated);
Node <CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);
openParenthesis.MatchingBracketNode = closeParenthesisNode;
closeParenthesis.MatchingBracketNode = openParenthesisNode;
// Create the token list for the expression.
CsTokenList partialTokens = new CsTokenList(this.tokens, openParenthesisNode, this.tokens.Last);
// Create and return the expression.
ParenthesizedExpression expression = new ParenthesizedExpression(partialTokens, innerExpression);
expressionReference.Target = expression;
return(expression);
}
/// <summary>
/// Initializes a new instance of the DictionaryItemInitializationExpression class.
/// </summary>
/// <param name="tokens">The list of tokens that form the statement.</param>
/// <param name="initializer">The initializer expression or null.</param>
internal DictionaryItemInitializationExpression(CsTokenList tokens, Expression initializer)
: base(ExpressionType.ArrayInitializer, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(initializer);
if (initializer != null)
{
this.AddExpression(initializer);
}
}
/// <summary>
/// Returns true if the node Contains any sort of <see cref="Nullable"/>.
/// </summary>
/// <param name="token">
/// The token to check.
/// </param>
/// <returns>
/// True if <see cref="Nullable"/> otherwise False.
/// </returns>
public static bool TokenContainNullable(Node <CsToken> token)
{
if (CsTokenList.MatchTokens(StringComparison.Ordinal, token, new[] { "System", ".", "Nullable" }) ||
CsTokenList.MatchTokens(StringComparison.Ordinal, token, new[] { "global", "::", "System", ".", "Nullable" }) ||
token.Value.Text.Equals("Nullable", StringComparison.Ordinal))
{
return(true);
}
return(false);
}
/// <summary>
/// Initializes a new instance of the CodeUnit class.
/// </summary>
/// <param name="codeUnitType">
/// The type of the code unit.
/// </param>
/// <param name="tokens">
/// The list of tokens that form the code unit.
/// </param>
internal CodeUnit(CodePartType codeUnitType, CsTokenList tokens)
: this(codeUnitType)
{
Param.Ignore(codeUnitType);
Param.AssertNotNull(tokens, "tokens");
this.tokens = tokens;
this.tokens.Trim();
Debug.Assert(this.tokens.First != null, "The tokens should not be empty");
}
/// <summary>
/// Checks a method or method invocation to ensure that the closing bracket is
/// on the same line as the last parameter.
/// </summary>
/// <param name="element">
/// The element containing the expression.
/// </param>
/// <param name="parameterListTokens">
/// The tokens that form the parameter list.
/// </param>
/// <param name="openingBracketNode">
/// The opening bracket.
/// </param>
/// <param name="closingBracketType">
/// The type of the closing bracket.
/// </param>
/// <param name="arguments">
/// The arguments to the method.
/// </param>
private void CheckMethodClosingBracket(
CsElement element, CsTokenList parameterListTokens, Node <CsToken> openingBracketNode, CsTokenType closingBracketType, IArgumentList arguments)
{
Param.AssertNotNull(element, "element");
Param.AssertNotNull(parameterListTokens, "parameterListTokens");
Param.AssertNotNull(openingBracketNode, "openingBracket");
Param.Ignore(closingBracketType);
Param.AssertNotNull(arguments, "arguments");
// Find the closing bracket.
Node <CsToken> closingBracketNode = null;
for (Node <CsToken> tokenNode = parameterListTokens.Last; tokenNode != null; tokenNode = tokenNode.Previous)
{
if (tokenNode.Value.CsTokenType == closingBracketType)
{
closingBracketNode = tokenNode;
break;
}
}
if (closingBracketNode != null)
{
if (arguments.Count == 0)
{
// The closing bracket must be on the same line as the opening bracket.
if (openingBracketNode.Value.LineNumber != closingBracketNode.Value.LineNumber)
{
// If the brackets are not on the same line, determine if this is because there are comments
// between the brackets.
int commentLineSpan = MeasureCommentLinesBetween(openingBracketNode, closingBracketNode, false);
if (openingBracketNode.Value.LineNumber + commentLineSpan != closingBracketNode.Value.LineNumber)
{
this.AddViolation(element, closingBracketNode.Value.LineNumber, Rules.ClosingParenthesisMustBeOnLineOfOpeningParenthesis);
}
}
}
else
{
// The closing bracket must be on the same line as the end of the last method argument.
int lastArgumentEndLine = arguments.Location(arguments.Count - 1).EndPoint.LineNumber;
if (lastArgumentEndLine != closingBracketNode.Value.LineNumber)
{
int commentLineSpan = MeasureCommentLinesBetween(arguments.Tokens(arguments.Count - 1).Last, closingBracketNode, false);
if (lastArgumentEndLine + commentLineSpan != closingBracketNode.Value.LineNumber)
{
this.AddViolation(element, closingBracketNode.Value.LineNumber, Rules.ClosingParenthesisMustBeOnLineOfLastParameter);
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the ArrayInitializerExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="initializers">
/// The list of variable initializers within the
/// array initializer expression.
/// </param>
internal ArrayInitializerExpression(CsTokenList tokens, ICollection <Expression> initializers)
: base(ExpressionType.ArrayInitializer, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(initializers, "initializers");
this.initializers = initializers;
Debug.Assert(initializers.IsReadOnly, "The initializers collection should be read-only.");
this.AddExpressions(initializers);
}
/// <summary>
/// Initializes a new instance of the DefaultValueExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="type">
/// The type to obtain the default value of.
/// </param>
/// <param name="parent">
/// The parent reference of this expression.
/// </param>
internal DefaultValueExpression(CsTokenList tokens, LiteralExpression type, Reference <ICodePart> parent)
: base(ExpressionType.DefaultValue, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(type, "type");
this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
this.AddExpression(type);
this.parent = parent;
}
/// <summary>
/// Initializes a new instance of the VariableDeclarationStatement class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the statement.
/// </param>
/// <param name="constant">
/// Indicates whether the item is constant.
/// </param>
/// <param name="expression">
/// The inner expression.
/// </param>
internal VariableDeclarationStatement(CsTokenList tokens, bool constant, VariableDeclarationExpression expression)
: base(StatementType.VariableDeclaration, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(constant);
Param.AssertNotNull(expression, "expression");
this.constant = constant;
this.expression = expression;
this.AddExpression(expression);
}
/// <summary>
/// Initializes a new instance of the UnaryExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="operatorType">
/// The type of operation being performed.
/// </param>
/// <param name="value">
/// The value the operator is being applied to.
/// </param>
internal UnaryExpression(CsTokenList tokens, Operator operatorType, Expression value)
: base(ExpressionType.Unary, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(operatorType);
Param.AssertNotNull(value, "value");
this.operatorType = operatorType;
this.value = value;
this.AddExpression(value);
}
/// <summary>
/// Initializes a new instance of the DecrementExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="value">
/// The value being decremented.
/// </param>
/// <param name="decrementType">
/// The type of decrement being performed.
/// </param>
internal DecrementExpression(CsTokenList tokens, Expression value, DecrementType decrementType)
: base(ExpressionType.Decrement, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(value, "value");
Param.Ignore(decrementType);
this.value = value;
this.decrementType = decrementType;
this.AddExpression(value);
}
/// <summary>
/// Initializes a new instance of the IncrementExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="value">
/// The value being incremented.
/// </param>
/// <param name="incrementType">
/// The type of increment being performed.
/// </param>
internal IncrementExpression(CsTokenList tokens, Expression value, IncrementType incrementType)
: base(ExpressionType.Increment, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(value, "value");
Param.Ignore(incrementType);
this.value = value;
this.incrementType = incrementType;
this.AddExpression(value);
}
/// <summary>
/// Initializes a new instance of the QueryExpression class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the expression.
/// </param>
/// <param name="clauses">
/// The collection of clauses in the expression.
/// </param>
internal QueryExpression(CsTokenList tokens, ICollection <QueryClause> clauses)
: base(ExpressionType.Query, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.AssertNotNull(clauses, "clauses");
this.clauses = new CodeUnitCollection <QueryClause>(this);
this.clauses.AddRange(clauses);
this.InitializeFromClauses(clauses);
Debug.Assert(clauses.IsReadOnly, "The collection of query clauses should be read-only.");
}
/// <summary>
/// Initializes a new instance of the ElseStatement class.
/// </summary>
/// <param name="tokens">
/// The list of tokens that form the statement.
/// </param>
/// <param name="conditionExpression">
/// The expression within the if portion of this
/// else-statement, if any.
/// </param>
internal ElseStatement(CsTokenList tokens, Expression conditionExpression)
: base(StatementType.Else, tokens)
{
Param.AssertNotNull(tokens, "tokens");
Param.Ignore(conditionExpression);
this.conditionExpression = conditionExpression;
if (conditionExpression != null)
{
this.AddExpression(conditionExpression);
}
}
