private ConstructorDeclarationSyntax ParseConstructorDeclaration(string typeName, SyntaxListBuilder <AnnotationSyntax> attributes, SyntaxListBuilder modifiers, TypeParameterListSyntax typeParameterList)
{
var name = this.ParseIdentifierToken();
Debug.Assert(name.ValueText == typeName);
var saveTerm = this._termState;
this._termState |= TerminatorState.IsEndOfMethodSignature;
try
{
var paramList = this.ParseParenthesizedParameterList(allowThisKeyword: false, allowDefaults: true, allowAttributes: true, allowFieldModifiers: false);
JavaThrowsListClauseSyntax throws = this.ParseJavaThrowsListClause(true);
ConstructorInitializerSyntax initializer = null;
if (this.CurrentToken.Kind == SyntaxKind.ColonToken)
{
bool isStatic = modifiers != null && modifiers.Any(SyntaxKind.StaticKeyword);
initializer = this.ParseConstructorInitializer(name.ValueText, isStatic);
}
BlockSyntax body;
SyntaxToken semicolon;
this.ParseBodyOrSemicolon(out body, out semicolon);
return(_syntaxFactory.ConstructorDeclaration(attributes, modifiers.ToTokenList(), typeParameterList, name, paramList, throws, initializer, body, semicolon));
}
finally
{
this._termState = saveTerm;
}
}
private FieldDeclarationSyntax ParseNormalFieldDeclaration(
SyntaxListBuilder <AnnotationSyntax> attributes,
SyntaxListBuilder modifiers,
TypeSyntax type,
SyntaxKind parentKind)
{
var saveTerm = this._termState;
this._termState |= TerminatorState.IsEndOfFieldDeclaration;
var variables = this._pool.AllocateSeparated <VariableDeclaratorSyntax>();
try
{
this.ParseVariableDeclarators(type, flags: 0, variables: variables, parentKind: parentKind);
var semicolon = this.EatToken(SyntaxKind.SemicolonToken);
return(_syntaxFactory.FieldDeclaration(
attributes,
modifiers.ToTokenList(),
_syntaxFactory.VariableDeclaration(type, variables),
semicolon));
}
finally
{
this._termState = saveTerm;
this._pool.Free(variables);
}
}
private MethodDeclarationSyntax ParseMethodDeclaration(
SyntaxListBuilder <AnnotationSyntax> attributes,
SyntaxListBuilder modifiers,
TypeSyntax type,
SyntaxToken identifier,
TypeParameterListSyntax typeParameterList, bool isDtor)
{
// Parse the name (it could be qualified)
var saveTerm = this._termState;
this._termState |= TerminatorState.IsEndOfMethodSignature;
var paramList = this.ParseParenthesizedParameterList(allowThisKeyword: true, allowDefaults: true,
allowAttributes: true, allowFieldModifiers: true);
JavaThrowsListClauseSyntax throws = this.ParseJavaThrowsListClause(true);
if (this.CurrentToken.Kind == SyntaxKind.ColonToken)
{
// Use else if, rather than if, because if we see both a constructor initializer and a constraint clause, we're too lost to recover.
var colonToken = this.CurrentToken;
// Set isStatic to false because pretending we're in a static constructor will just result in more errors.
ConstructorInitializerSyntax initializer = this.ParseConstructorInitializer(identifier.ValueText, isStatic: false);
initializer = this.AddErrorToFirstToken(initializer, ErrorCode.ERR_UnexpectedCharacter, colonToken.Text);
//CONSIDER: better error code?
paramList = AddTrailingSkippedSyntax(paramList, initializer);
// CONSIDER: Parsing an invalid constructor initializer could, conceivably, get us way
// off track. If this becomes a problem, an alternative approach would be to generalize
// EatTokenWithPrejudice in such a way that we can just skip everything until we recognize
// our context again (perhaps an open brace).
}
this._termState = saveTerm;
BlockSyntax body;
SyntaxToken semicolon;
this.ParseBodyOrSemicolon(out body, out semicolon);
return
(_syntaxFactory.MethodDeclaration(isDtor ? SyntaxKind.DestructorDeclaration : SyntaxKind.MethodDeclaration,
attributes,
modifiers.ToTokenList(),
typeParameterList,
type,
identifier,
paramList,
throws,
body,
semicolon));
}
public JavaMemberModifierSyntax CreateJavaMemberModifierSyntax(SyntaxListBuilder <AnnotationSyntax> attributes,
SyntaxListBuilder modifiers)
{
JavaMemberModifierSyntax modifier = default(JavaMemberModifierSyntax);
if (attributes.Count != 0 || modifiers.Count != 0)
{
modifier = _syntaxFactory.JavaMemberModifier(attributes, modifiers.ToTokenList());
}
return(modifier);
}
private ParameterSyntax ParseParameter(
SyntaxListBuilder <AnnotationSyntax> attributes,
SyntaxListBuilder modifiers,
bool allowThisKeyword,
bool allowDefaults,
bool allowAttributes,
bool allowFieldModifiers)
{
if (this.IsIncrementalAndFactoryContextMatches && CanReuseParameter(this.CurrentNode as CSharp.Syntax.ParameterSyntax, attributes, modifiers))
{
return((ParameterSyntax)this.EatNode());
}
this.ParseAnnotationDeclarations(attributes, allowAttributes);
this.ParseParameterModifiers(modifiers, allowThisKeyword, allowFieldModifiers);
TypeSyntax type = null;
type = this.ParseType(true);
var hasArgList = this.CurrentToken.Kind == SyntaxKind.DotDotDotToken;
SyntaxToken dotdotdotTk = default(SyntaxToken);
if (hasArgList)
{
dotdotdotTk = this.EatToken(SyntaxKind.DotDotDotToken);
}
SyntaxToken name = null;
//if (!hasArgList)
{
name = this.ParseIdentifierToken();
// When the user type "int foo[]", give them a useful error
if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind == SyntaxKind.CloseBracketToken)
{
var open = this.EatToken();
var close = this.EatToken();
open = this.AddError(open, ErrorCode.ERR_BadArraySyntax);
name = AddTrailingSkippedSyntax(name, SyntaxList.List(open, close));
}
}
//else if (this.IsPossibleName())
//{
// // Current token is an identifier token, we expected a CloseParenToken.
// // Get the expected token error for the missing token with correct diagnostic
// // span and then parse the identifier token.
// SyntaxDiagnosticInfo diag = this.GetExpectedTokenError(SyntaxKind.CloseParenToken, SyntaxKind.IdentifierToken);
// name = this.ParseIdentifierToken();
// name = WithAdditionalDiagnostics(name, diag);
//}
//else
//{
// // name is not optional on ParameterSyntax
// name = this.EatToken(SyntaxKind.ArgListKeyword);
//}
EqualsValueClauseSyntax def = null;
if (this.CurrentToken.Kind == SyntaxKind.EqualsToken)
{
var equals = this.EatToken(SyntaxKind.EqualsToken);
var expr = this.ParseExpression();
def = _syntaxFactory.EqualsValueClause(equals, expr);
if (!allowDefaults)
{
def = this.AddError(def, equals, ErrorCode.ERR_DefaultValueNotAllowed);
}
else
{
def = CheckFeatureAvailability(def, MessageID.IDS_FeatureOptionalParameter);
}
}
return(_syntaxFactory.Parameter(attributes, modifiers.ToTokenList(), type, dotdotdotTk, name, def));
}
private JavaInitializerMethodDeclarationSyntax ParseJavaInitializerMethodDeclaration(SyntaxListBuilder modifiers)
{
//InstanceInitializer:
// Block
//StaticInitializer:
// static Block
SyntaxToken staticKeyword = default(SyntaxToken);
var modifiersTokens = modifiers.ToTokenList();
//if (modifiersTokens.Count > 0)
//{
// var token = modifiersTokens[0];
// if (token.Kind != SyntaxKind.StaticKeyword)
// {
// token = this.AddError(token, ErrorCode.ERR_BadModifierLocation);
// //token = this.ConvertToMissingWithTrailingTrivia(token, SyntaxKind.StaticKeyword);
// }
// staticKeyword = token;
//}
bool haveStatic = modifiersTokens.Any(SyntaxKind.StaticKeyword);
//ÓÐstatic ÇÒ ÐÞÊηû¾ÍÒ»¸ö
if (haveStatic && modifiersTokens.Count == 1)
{
staticKeyword = modifiersTokens[0];
}
else if (haveStatic && modifiersTokens.Count != 1)
{
int staticIndex = -1;
for (int i = 0; i < modifiersTokens.Count; i++)
{
if (modifiersTokens[i].Kind == SyntaxKind.StaticKeyword)
{
staticIndex = i;
break;
}
}
staticKeyword = modifiersTokens[staticIndex];
for (int i = 0; i < modifiersTokens.Count; i++)
{
if (i != staticIndex)
{
if (i < staticIndex)
{
staticKeyword = this.AddLeadingSkippedSyntax(staticKeyword, this.AddErrorToFirstToken(modifiersTokens[i], ErrorCode.ERR_BadModifierLocation));
}
else if (i > staticIndex)
{
staticKeyword = this.AddTrailingSkippedSyntax(staticKeyword, this.AddErrorToFirstToken(modifiersTokens[i], ErrorCode.ERR_BadModifierLocation));
}
}
}
}
else if (!haveStatic && modifiersTokens.Count != 0)
{
staticKeyword = Syntax.InternalSyntax.SyntaxFactory.MissingToken(SyntaxKind.StaticKeyword);
foreach (SyntaxToken t in modifiersTokens)
{
staticKeyword = this.AddLeadingSkippedSyntax(staticKeyword, this.AddErrorToFirstToken(t, ErrorCode.ERR_BadModifierLocation));
}
}
var saveTerm = this._termState;
this._termState |= TerminatorState.IsEndOfMethodSignature;
try
{
if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken)
{
BlockSyntax body = this.ParseBlock(isMethodBody: true);
return(_syntaxFactory.JavaInitializerMethodDeclaration(staticKeyword, body));
}
}
finally
{
this._termState = saveTerm;
}
return(null);
}
