/// <summary>
/// Initializes a new instance of the UsingDirective class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
/// <param name="namespace">The namespace being used.</param>
/// <param name="alias">Optional alias for the namespace, if any.</param>
internal UsingDirective(
CsDocument document,
CsElement parent,
Declaration declaration,
bool generated,
string @namespace,
string alias)
: base(document,
parent,
ElementType.UsingDirective,
"using " + declaration.Name,
null,
null,
declaration,
false,
generated)
{
Param.Ignore(document);
Param.Ignore(parent);
Param.Ignore(declaration);
Param.Ignore(generated);
Param.AssertValidString(@namespace, "namespace");
Param.Ignore(alias);
this.namespaceType = @namespace;
if (alias != null)
{
this.alias = alias;
}
}
/// <summary>
/// Initializes a new instance of the EnumItem class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for 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>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal EnumItem(
CsDocument document,
Enum parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
Expression initialization,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.EnumItem,
"enum item " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.Ignore(document, parent, header, attributes, declaration, initialization, unsafeCode, generated);
this.initialization = initialization;
if (this.initialization != null)
{
this.AddExpression(this.initialization);
}
}
internal Field(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken fieldType, bool unsafeCode, bool generated)
: base(document, parent, ElementType.Field, "field " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
{
this.type = fieldType;
this.isConst = base.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Const });
this.isReadOnly = base.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Readonly });
}
/// <summary>
/// Initializes a new instance of the Destructor class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Destructor(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Destructor,
"destructor " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
// Static destructors are always public.
if (this.Declaration.ContainsModifier(CsTokenType.Static))
{
this.Declaration.AccessModifierType = AccessModifierType.Public;
}
}
/// <summary>
/// Initializes a new instance of the ClassBase class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="type">The element type.</param>
/// <param name="name">The name of this element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="typeConstraints">The list of type constraints on the element.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal ClassBase(
CsDocument document,
CsElement parent,
ElementType type,
string name,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
ICollection<TypeParameterConstraintClause> typeConstraints,
bool unsafeCode,
bool generated)
: base(document, parent, type, name, header, attributes, declaration, unsafeCode, generated)
{
Param.Ignore(document, parent, type, name, header, attributes, declaration, typeConstraints, unsafeCode, generated);
this.typeConstraints = typeConstraints;
// Set the parent of the type constraint clauses.
if (typeConstraints != null)
{
Debug.Assert(typeConstraints.IsReadOnly, "The typeconstraints collection should be read-only.");
foreach (TypeParameterConstraintClause constraint in typeConstraints)
{
constraint.ParentElement = this;
}
}
}
internal Method(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken returnType, IList<Parameter> parameters, ICollection<TypeParameterConstraintClause> typeConstraints, bool unsafeCode, bool generated)
: base(document, parent, ElementType.Method, "method " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
{
this.returnType = returnType;
this.parameters = parameters;
this.typeConstraints = typeConstraints;
if ((this.parameters.Count > 0) && base.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Static }))
{
foreach (Parameter parameter in this.parameters)
{
if ((parameter.Modifiers & ParameterModifiers.This) != ParameterModifiers.None)
{
this.extensionMethod = true;
}
break;
}
}
base.QualifiedName = CodeParser.AddQualifications(this.parameters, base.QualifiedName);
if ((base.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1) && !base.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
{
base.Declaration.AccessModifierType = AccessModifierType.Public;
}
if (typeConstraints != null)
{
foreach (TypeParameterConstraintClause clause in typeConstraints)
{
clause.ParentElement = this;
}
}
}
/// <summary>
/// Initializes a new instance of the Field class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="fieldType">The type of the field.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Field(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
TypeToken fieldType,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Field,
"field " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.AssertNotNull(fieldType, "fieldType");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
this.type = fieldType;
// Determine whether the item is const or readonly.
this.isConst = this.Declaration.ContainsModifier(CsTokenType.Const);
this.isReadOnly = this.Declaration.ContainsModifier(CsTokenType.Readonly);
}
protected void SetInheritedItems(Declaration declaration)
{
Param.RequireNotNull(declaration, "declaration");
bool flag = false;
bool flag2 = false;
List<string> list = new List<string>();
foreach (CsToken token in declaration.Tokens)
{
if (flag)
{
if ((((token.CsTokenType != CsTokenType.WhiteSpace) && (token.CsTokenType != CsTokenType.EndOfLine)) && ((token.CsTokenType != CsTokenType.SingleLineComment) && (token.CsTokenType != CsTokenType.MultiLineComment))) && (token.CsTokenType != CsTokenType.PreprocessorDirective))
{
if (((token.Text.Length >= 2) && (token.Text[0] == 'I')) && char.IsUpper(token.Text[1]))
{
list.Add(CodeParser.TrimType(token.Text));
}
else
{
this.baseClass = CodeParser.TrimType(token.Text);
}
flag = false;
}
continue;
}
if (flag2)
{
if ((((token.CsTokenType != CsTokenType.WhiteSpace) && (token.CsTokenType != CsTokenType.EndOfLine)) && ((token.CsTokenType != CsTokenType.SingleLineComment) && (token.CsTokenType != CsTokenType.MultiLineComment))) && (token.CsTokenType != CsTokenType.PreprocessorDirective))
{
list.Add(CodeParser.TrimType(token.Text));
flag2 = false;
}
}
else
{
if (token.CsTokenType == CsTokenType.Where)
{
break;
}
if (token.Text == ":")
{
if (this.baseClass.Length > 0)
{
break;
}
flag = true;
continue;
}
if (token.CsTokenType == CsTokenType.Comma)
{
flag2 = true;
}
}
}
if (list.Count > 0)
{
this.implementedInterfaces = list.ToArray();
}
}
internal Property(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken returnType, bool unsafeCode, bool generated)
: base(document, parent, ElementType.Property, "property " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
{
this.returnType = returnType;
if ((base.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1) && !base.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
{
base.Declaration.AccessModifierType = AccessModifierType.Public;
}
}
internal UsingDirective(CsDocument document, CsElement parent, Declaration declaration, bool generated, string @namespace, string alias)
: base(document, parent, ElementType.UsingDirective, "using " + declaration.Name, null, null, declaration, false, generated)
{
this.namespaceType = string.Empty;
this.alias = string.Empty;
this.namespaceType = @namespace;
if (alias != null)
{
this.alias = alias;
}
}
internal Indexer(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken returnType, IList<Parameter> parameters, bool unsafeCode, bool generated)
: base(document, parent, ElementType.Indexer, "indexer " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
{
this.returnType = returnType;
this.parameters = parameters;
base.QualifiedName = CodeParser.AddQualifications(this.parameters, base.QualifiedName);
if ((base.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1) && !base.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
{
base.Declaration.AccessModifierType = AccessModifierType.Public;
}
}
/// <summary>
/// Initializes a new instance of the Delegate class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="returnType">The return type.</param>
/// <param name="parameters">The parameters to the delegate.</param>
/// <param name="typeConstraints">The list of type constraints on the element.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether this is generated code.</param>
internal Delegate(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
TypeToken returnType,
IList<Parameter> parameters,
ICollection<TypeParameterConstraintClause> typeConstraints,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Delegate,
"delegate " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.AssertNotNull(returnType, "returnType");
Param.AssertNotNull(parameters, "parameters");
Param.Ignore(typeConstraints);
Param.Ignore(unsafeCode);
Param.Ignore(generated);
this.returnType = returnType;
this.typeConstraints = typeConstraints;
this.parameters = parameters;
Debug.Assert(parameters.IsReadOnly, "The parameters collection should be read-only.");
// Add the qualifications
this.QualifiedName = CodeParser.AddQualifications(this.parameters, this.QualifiedName);
// Set the parent of the type constraint clauses.
if (typeConstraints != null)
{
Debug.Assert(typeConstraints.IsReadOnly, "The collection of type constraints should be read-only.");
foreach (TypeParameterConstraintClause constraint in typeConstraints)
{
constraint.ParentElement = this;
}
}
}
/// <summary>
/// Initializes a new instance of the Constructor class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="parameters">The parameters to the constructor.</param>
/// <param name="initializerExpression">The constructor initializer, if there is one.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Constructor(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
IList<Parameter> parameters,
MethodInvocationExpression initializerExpression,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Constructor,
"constructor " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.AssertNotNull(parameters, "parameters");
Param.Ignore(initializerExpression);
Param.Ignore(unsafeCode);
Param.Ignore(generated);
// Static constructors are always public.
if (this.Declaration.ContainsModifier(CsTokenType.Static))
{
this.Declaration.AccessModifierType = AccessModifierType.Public;
}
this.parameters = parameters;
Debug.Assert(parameters.IsReadOnly, "The parameters collection should be read-only.");
// Add the qualifications
this.QualifiedName = CodeParser.AddQualifications(this.parameters, this.QualifiedName);
// If there is an initializer expression, add it to the statement list for this constructor.
if (initializerExpression != null)
{
this.initializer = initializerExpression;
ConstructorInitializerStatement initializerStatement = new ConstructorInitializerStatement(
initializerExpression.Tokens, initializerExpression);
this.AddStatement(initializerStatement);
}
}
internal ClassBase(CsDocument document, CsElement parent, ElementType type, string name, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, ICollection<TypeParameterConstraintClause> typeConstraints, bool unsafeCode, bool generated)
: base(document, parent, type, name, header, attributes, declaration, unsafeCode, generated)
{
this.baseClass = string.Empty;
this.implementedInterfaces = new string[0];
this.typeConstraints = typeConstraints;
if (typeConstraints != null)
{
foreach (TypeParameterConstraintClause clause in typeConstraints)
{
clause.ParentElement = this;
}
}
}
/// <summary>
/// Initializes a new instance of the DocumentRoot class.
/// </summary>
/// <param name="document">The document that this element belongs to.</param>
/// <param name="declaration">The decleration class for this element.</param>
/// <param name="generated">Indicates whether the element contains generated code.</param>
internal DocumentRoot(CsDocument document, Declaration declaration, bool generated)
: base(document,
null,
ElementType.Root,
Strings.DocumentRoot,
null,
null,
declaration,
false,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(declaration, "declaration");
Param.Ignore(generated);
}
/// <summary>
/// Initializes a new instance of the ExternAliasDirective class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal ExternAliasDirective(
CsDocument document,
CsElement parent,
Declaration declaration,
bool generated)
: base(document,
parent,
ElementType.ExternAliasDirective,
"extern alias " + declaration.Name,
null,
null,
declaration,
false,
generated)
{
Param.Ignore(document, parent, declaration, generated);
}
/// <summary>
/// Initializes a new instance of the Indexer class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="returnType">The return type of the indexer.</param>
/// <param name="parameters">The parameters to the indexer.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Indexer(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
TypeToken returnType,
IList<Parameter> parameters,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Indexer,
"indexer " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.Ignore(returnType);
Param.AssertNotNull(parameters, "parameters");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
this.returnType = returnType;
this.parameters = parameters;
Debug.Assert(parameters.IsReadOnly, "The parameters collection should be read-only.");
// Add the qualifications
this.QualifiedName = CodeParser.AddQualifications(this.parameters, this.QualifiedName);
// If this is an explicit interface member implementation and our access modifier
// is currently set to private because we don't have one, then it should be public instead.
if (this.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1 &&
!this.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
{
this.Declaration.AccessModifierType = AccessModifierType.Public;
}
}
/// <summary>
/// Initializes a new instance of the Namespace class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Namespace(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Namespace,
"namespace " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.Ignore(document, parent, header, attributes, declaration, unsafeCode, generated);
}
/// <summary>
/// Initializes a new instance of the Accessor class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="accessorType">The type of the accessor.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Accessor(
CsDocument document,
CsElement parent,
AccessorType accessorType,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Accessor,
declaration.Name + " accessor",
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(accessorType);
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
this.accessorType = accessorType;
// Make sure the type and name match.
Debug.Assert(
(accessorType == AccessorType.Get && declaration.Name == "get") ||
(accessorType == AccessorType.Set && declaration.Name == "set") ||
(accessorType == AccessorType.Add && declaration.Name == "add") ||
(accessorType == AccessorType.Remove && declaration.Name == "remove"),
"The accessor type does not match its name.");
this.FillDetails(parent);
}
/// <summary>
/// Initializes a new instance of the EmptyElement class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal EmptyElement(
CsDocument document,
CsElement parent,
Declaration declaration,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.EmptyElement,
Strings.EmptyElement,
null,
null,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(declaration, "declaration");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
}
/// <summary>
/// Initializes a new instance of the Interface class.
/// </summary>
/// <param name="document">The document that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for 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>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Interface(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
ICollection<TypeParameterConstraintClause> typeConstraints,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Interface,
"interface " + declaration.Name,
header,
attributes,
declaration,
typeConstraints,
unsafeCode,
generated)
{
Param.Ignore(document, parent, header, attributes, declaration, typeConstraints, unsafeCode, generated);
}
/// <summary>
/// Initializes a new instance of the Property class.
/// </summary>
/// <param name="document">The documenent that contains the element.</param>
/// <param name="parent">The parent of the element.</param>
/// <param name="header">The Xml header for this element.</param>
/// <param name="attributes">The list of attributes attached to this element.</param>
/// <param name="declaration">The declaration code for this element.</param>
/// <param name="returnType">The property return type.</param>
/// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
/// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
internal Property(
CsDocument document,
CsElement parent,
XmlHeader header,
ICollection<Attribute> attributes,
Declaration declaration,
TypeToken returnType,
bool unsafeCode,
bool generated)
: base(document,
parent,
ElementType.Property,
"property " + declaration.Name,
header,
attributes,
declaration,
unsafeCode,
generated)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parent, "parent");
Param.Ignore(header);
Param.Ignore(attributes);
Param.AssertNotNull(declaration, "declaration");
Param.AssertNotNull(returnType, "returnType");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
this.returnType = returnType;
// If this is an explicit interface member implementation and our access modifier
// is currently set to private because we don't have one, then it should be public instead.
if (this.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1 &&
!this.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
{
this.Declaration.AccessModifierType = AccessModifierType.Public;
}
}
/// <summary>
/// Parses and returns a field.
/// </summary>
/// <param name="parent">The parent of the element.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Field ParseField(
CsElement parent,
Reference<ICodePart> elementReference,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
Node<CsToken> previousTokenNode = this.tokens.Last;
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, FieldModifiers);
unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe);
// Get the field type.
TypeToken fieldType = this.GetTypeToken(elementReference, unsafeCode, true);
Node<CsToken> fieldTypeNode = this.tokens.InsertLast(fieldType);
// Get all of the variable declarators.
IList<VariableDeclaratorExpression> declarators = this.ParseFieldDeclarators(elementReference, unsafeCode, fieldType);
if (declarators.Count == 0)
{
throw this.CreateSyntaxException();
}
VariableDeclarationExpression declarationExpression = new VariableDeclarationExpression(
new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last),
new LiteralExpression(this.tokens, fieldTypeNode),
declarators);
// Create the field.
Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next;
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens, declarators[0].Identifier.Text, ElementType.Field, accessModifier, modifiers);
Field field = new Field(
this.document, parent, xmlHeader, attributes, declaration, fieldType, unsafeCode, generated);
elementReference.Target = field;
// Get the trailing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
// Create the variable declaration statement and add it to the field.
field.VariableDeclarationStatement = new VariableDeclarationStatement(
new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last),
field.Const,
declarationExpression);
return field;
}
/// <summary>
/// Parses and returns a event.
/// </summary>
/// <param name="parent">The parent of the element.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Event ParseEvent(
CsElement parent,
Reference<ICodePart> elementReference,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
Node<CsToken> previousTokenNode = this.tokens.Last;
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
// Events within interfaces always have the access of the parent interface.
Interface parentInterface = parent as Interface;
if (parentInterface != null)
{
accessModifier = parentInterface.AccessModifier;
}
// Get declared modifiers.
Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, EventModifiers);
unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe);
// Get the event keyword.
this.tokens.Add(this.GetToken(CsTokenType.Event, SymbolType.Event, elementReference));
// Get the event type.
TypeToken eventHandlerType = this.GetTypeToken(elementReference, unsafeCode, true);
this.tokens.Add(eventHandlerType);
List<EventDeclaratorExpression> declarators = new List<EventDeclaratorExpression>();
string firstEventName = null;
while (true)
{
Symbol symbol = this.GetNextSymbol(SymbolType.Other, elementReference);
var declaratorExpressionReference = new Reference<ICodePart>();
// Get the identifier.
LiteralExpression identifier = this.GetTypeTokenExpression(declaratorExpressionReference, unsafeCode, false);
if (identifier == null || identifier.Tokens.First == null)
{
throw new SyntaxException(this.document.SourceCode, symbol.LineNumber);
}
if (firstEventName == null)
{
firstEventName = identifier.Token.Text;
}
// Get the initializer if it exists.
Expression initializer = null;
symbol = this.GetNextSymbol(declaratorExpressionReference);
if (symbol.SymbolType == SymbolType.Equals)
{
// Add the equals token.
this.tokens.Add(this.GetOperatorToken(OperatorType.Equals, declaratorExpressionReference));
initializer = this.GetNextExpression(ExpressionPrecedence.None, declaratorExpressionReference, unsafeCode);
}
// Create the token list for the declarator.
CsTokenList partialTokens = new CsTokenList(
this.tokens, identifier.Tokens.First, this.tokens.Last);
// Create and add the declarator.
var declaratorExpression = new EventDeclaratorExpression(partialTokens, identifier, initializer);
declaratorExpressionReference.Target = declaratorExpression;
declarators.Add(declaratorExpression);
// Now check if the next character is a comma. If so there is another declarator.
symbol = this.GetNextSymbol(elementReference);
if (symbol.SymbolType != SymbolType.Comma)
{
// There are no more declarators.
break;
}
// Add the comma.
this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma, elementReference));
}
// Create the declaration.
Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next;
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens, firstEventName, ElementType.Event, accessModifier, modifiers);
Event @event = new Event(
this.document, parent, xmlHeader, attributes, declaration, eventHandlerType, declarators.ToArray(), unsafeCode, generated);
elementReference.Target = @event;
Symbol s = this.GetNextSymbol(elementReference);
if (s.SymbolType == SymbolType.Semicolon)
{
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
}
else
{
// Parse the body of the event.
this.ParseElementContainer(@event, elementReference, null, unsafeCode);
}
return @event;
}
/// <summary>
/// Parses the contents of the document.
/// </summary>
internal void ParseDocument()
{
Debug.Assert(this.document == null, "A CodeParser instance may only be used once.");
// Find the list of symbols in the document.
List<Symbol> symbolList = this.lexer.GetSymbols(
this.lexer.SourceCode, this.lexer.SourceCode.Project.Configuration);
// Create the symbol manager class.
this.symbols = new SymbolManager(symbolList);
// Create the document object.
this.document = new CsDocument(this.lexer.SourceCode, this.parser, this.tokens);
var documentRootReference = new Reference<ICodePart>();
// Get the file header if it exists.
FileHeader fileHeader = this.GetFileHeader(documentRootReference);
// Let the symbol manager know if this document contains generated code.
if (fileHeader.Generated)
{
this.symbols.IncrementGeneratedCodeBlocks();
}
this.document.FileHeader = fileHeader;
// Create a declaration for the root element.
Declaration declaration = new Declaration(
new CsTokenList(this.document.Tokens),
Strings.Root,
ElementType.Root,
AccessModifierType.Public,
new Dictionary<CsTokenType, CsToken>());
// Create the root element for the document.
DocumentRoot root = new DocumentRoot(this.document, declaration, fileHeader.Generated);
documentRootReference.Target = root;
// Parse the contents of the document.
this.ParseElementContainerBody(root, documentRootReference, this.parser.PartialElements, false);
// Check if there are any tokens in the document.
if (this.document.Tokens.Count > 0)
{
// Fill in the token list for the root element.
root.Tokens = new CsTokenList(
this.document.Tokens, this.document.Tokens.First, this.document.Tokens.Last);
// Fill in the location for the element.
root.Location = CsToken.JoinLocations(this.document.Tokens.First, this.document.Tokens.Last);
}
// Add the root element to the document.
this.document.RootElement = root;
// When in debug mode, ensure that all tokens are correctly mapped to a parent element.
this.DebugValidateParentReferences();
}
/// <summary>
/// Parses and returns a extern alias directive.
/// </summary>
/// <param name="parent">The parent of the namespace.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <returns>Returns the element.</returns>
private ExternAliasDirective ParseExternAliasDirective(CsElement parent, Reference<ICodePart> elementReference, bool generated)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(generated);
// Add the extern token.
Node<CsToken> firstToken = this.tokens.InsertLast(this.GetToken(CsTokenType.Extern, SymbolType.Extern, elementReference));
// Add the alias token.
this.tokens.Add(this.GetToken(CsTokenType.Alias, SymbolType.Other, elementReference));
// Add the identifier token.
CsToken identifier = this.GetToken(CsTokenType.Other, SymbolType.Other, elementReference);
this.tokens.Add(identifier);
// Create the declaration.
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstToken, this.tokens.Last);
Declaration declaration = new Declaration(declarationTokens, identifier.Text, ElementType.ExternAliasDirective, AccessModifierType.Public);
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
// Create the extern alias directive.
var element = new ExternAliasDirective(this.document, parent, declaration, generated);
elementReference.Target = element;
return element;
}
/// <summary>
/// Parses and returns a method.
/// </summary>
/// <param name="parent">The parent of the element.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Method ParseMethod(
CsElement parent,
Reference<ICodePart> elementReference,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
Node<CsToken> previousTokenNode = this.tokens.Last;
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
// Methods within interfaces always have the access of the parent interface.
Interface parentInterface = parent as Interface;
if (parentInterface != null)
{
accessModifier = parentInterface.AccessModifier;
}
// Get the declared modifiers for the method.
Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, MethodModifiers);
unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe);
TypeToken returnType = null;
if (!modifiers.ContainsKey(CsTokenType.Implicit) && !modifiers.ContainsKey(CsTokenType.Explicit))
{
// Get the return type.
returnType = this.GetTypeToken(elementReference, unsafeCode, true);
this.tokens.Add(returnType);
}
// Get the name of the method.
string methodName = null;
Symbol symbol = this.GetNextSymbol(elementReference);
if (symbol.SymbolType == SymbolType.Operator)
{
this.tokens.Add(this.GetToken(CsTokenType.Operator, SymbolType.Operator, elementReference));
// Advance up to the next symbol.
this.AdvanceToNextCodeSymbol(elementReference);
// The overloaded item will either be a type or a symbol.
int endIndex = -1;
CsToken operatorType = null;
if (this.HasTypeSignature(1, unsafeCode, out endIndex))
{
// The overloaded item is a type.
operatorType = this.GetTypeToken(elementReference, unsafeCode, true);
}
else
{
// The overloaded item is a symbol.
operatorType = this.ConvertOperatorOverloadSymbol(elementReference);
}
this.tokens.Add(operatorType);
methodName = "operator " + operatorType.Text;
}
else
{
CsToken name = this.GetElementNameToken(elementReference, unsafeCode);
methodName = name.Text;
this.tokens.Add(name);
}
// Get the parameter list.
IList<Parameter> parameters = this.ParseParameterList(
elementReference, unsafeCode, SymbolType.OpenParenthesis, modifiers.ContainsKey(CsTokenType.Static));
// Check whether there are any type constraint clauses.
ICollection<TypeParameterConstraintClause> typeConstraints = null;
symbol = this.GetNextSymbol(elementReference);
if (symbol.Text == "where")
{
typeConstraints = this.ParseTypeConstraintClauses(elementReference, unsafeCode);
}
// Create the declaration.
Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next;
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens, methodName, ElementType.Method, accessModifier, modifiers);
Method method = new Method(
this.document,
parent,
xmlHeader,
attributes,
declaration,
returnType,
parameters,
typeConstraints,
unsafeCode,
generated);
elementReference.Target = method;
// If the element is extern, abstract, or containing within an interface, it will not have a body.
if (modifiers.ContainsKey(CsTokenType.Abstract) ||
modifiers.ContainsKey(CsTokenType.Extern) ||
parent.ElementType == ElementType.Interface)
{
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
}
else
{
// Get the method body.
this.ParseStatementContainer(method, true, unsafeCode);
}
return method;
}
/// <summary>
/// Parses and returns a using directive.
/// </summary>
/// <param name="parent">The parent of the namespace.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <returns>Returns the element.</returns>
private UsingDirective ParseUsingDirective(CsElement parent, Reference<ICodePart> elementReference, bool unsafeCode, bool generated)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
// Add the using token.
Node<CsToken> firstToken = this.tokens.InsertLast(this.GetToken(CsTokenType.Using, SymbolType.Using, elementReference));
// The next symbol will either be the namespace, or an alias. To determine this, look past this to see if there is an equals sign.
Symbol peekAhead = this.GetNextSymbol(SymbolType.Other, elementReference);
int index = this.GetNextCodeSymbolIndex(2);
if (index == -1)
{
throw this.CreateSyntaxException();
}
CsToken alias = null;
peekAhead = this.symbols.Peek(index);
if (peekAhead.SymbolType == SymbolType.Equals)
{
// There is an alias. First collect the alias.
alias = this.GetToken(CsTokenType.Other, SymbolType.Other, elementReference);
this.tokens.Add(alias);
// Next collect the equals sign.
this.tokens.Add(this.GetOperatorToken(OperatorType.Equals, elementReference));
}
// Collect and add the namespace token.
TypeToken @namespace = this.GetTypeToken(elementReference, unsafeCode, false);
this.tokens.Add(@namespace);
// Create the declaration.
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstToken, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens,
alias == null ? @namespace.Text : alias.Text,
ElementType.UsingDirective,
AccessModifierType.Public);
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
// Create the using directive.
var element = new UsingDirective(this.document, parent, declaration, generated, @namespace.Text, alias == null ? null : alias.Text);
elementReference.Target = element;
return element;
}
/// <summary>
/// Parses and returns a property.
/// </summary>
/// <param name="parent">The parent of the element.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Property ParseProperty(
CsElement parent,
Reference<ICodePart> elementReference,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
Node<CsToken> previousTokenNode = this.tokens.Last;
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
// Properties within interfaces always have the access of the parent interface.
Interface parentInterface = parent as Interface;
if (parentInterface != null)
{
accessModifier = parentInterface.AccessModifier;
}
// Get declared modifiers.
Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, PropertyModifiers);
unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe);
// Get the return type.
TypeToken returnType = this.GetTypeToken(elementReference, unsafeCode, true);
this.tokens.Add(returnType);
// Get the name of the property.
CsToken name = this.GetElementNameToken(elementReference, unsafeCode);
this.tokens.Add(name);
// Create the declaration.
Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next;
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens, name.Text, ElementType.Property, accessModifier, modifiers);
Property property = new Property(
this.document, parent, xmlHeader, attributes, declaration, returnType, unsafeCode, generated);
elementReference.Target = property;
// Parse the body of the property.
this.ParseElementContainer(property, elementReference, null, unsafeCode);
return property;
}
/// <summary>
/// Parses and returns a namespace.
/// </summary>
/// <param name="parent">The parent of the namespace.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="partialElements">The collection of partial elements found while parsing the files.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Namespace ParseNamespace(
CsElement parent,
Reference<ICodePart> elementReference,
Dictionary<string, List<CsElement>> partialElements,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.AssertNotNull(partialElements, "partialElements");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
// Add the namespace token.
Node<CsToken> firstToken = this.tokens.InsertLast(this.GetToken(CsTokenType.Namespace, SymbolType.Namespace, elementReference));
// Add the namespace name token.
CsToken name = this.GetElementNameToken(elementReference, unsafeCode);
this.tokens.Add(name);
// Create the declaration.
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstToken, this.tokens.Last);
Declaration declaration = new Declaration(declarationTokens, name.Text, ElementType.Namespace, AccessModifierType.Public);
// Create the namespace.
Namespace @namespace = new Namespace(this.document, parent, xmlHeader, attributes, declaration, unsafeCode, generated);
elementReference.Target = @namespace;
// Parse the body of the namespace.
this.ParseElementContainer(@namespace, elementReference, partialElements, unsafeCode);
return @namespace;
}
