private void ParseModifiers(SyntaxListBuilder tokens)
{
SyntaxModifier mods = 0;
bool seenNoDuplicates = true;
bool seenNoAccessibilityDuplicates = true;
while (true)
{
var newMod = GetModifier(this.CurrentToken);
if (newMod == SyntaxModifier.None)
{
break;
}
SyntaxToken modTok = this.EatToken();
ReportDuplicateModifiers(ref modTok, newMod, mods, ref seenNoDuplicates, ref seenNoAccessibilityDuplicates);
mods |= newMod;
tokens.Add(modTok);
}
}
private void ReportDuplicateModifiers(ref SyntaxToken modTok, SyntaxModifier newMod, SyntaxModifier mods,
ref bool seenNoDuplicates, ref bool seenNoAccessibilityDuplicates)
{
if ((mods & newMod) != 0)
{
if (seenNoDuplicates)
{
modTok = this.AddError(modTok, ErrorCode.ERR_DuplicateModifier, SyntaxKindFacts.GetText(modTok.Kind));
seenNoDuplicates = false;
}
}
else
{
if ((mods & AccessModifiers) != 0 && (newMod & AccessModifiers) != 0)
{
if (seenNoAccessibilityDuplicates)
{
modTok = this.AddError(modTok, ErrorCode.ERR_BadMemberProtection);
}
seenNoAccessibilityDuplicates = false;
}
}
}
private void ParseParameterModifiers(SyntaxListBuilder modifiers, bool allowThisKeyword, bool allowFieldModifiers)
{
var flags = ParamFlags.None;
SyntaxModifier fieldMods = 0;
bool seenNoDuplicates = true;
bool seenNoAccessibilityDuplicates = true;
while (true)
{
if (IsParameterModifier(this.CurrentToken.Kind, allowThisKeyword))
{
var mod = this.EatToken();
if (mod.Kind == SyntaxKind.ThisKeyword)
{
if (mod.Kind == SyntaxKind.ThisKeyword)
{
mod = CheckFeatureAvailability(mod, MessageID.IDS_FeatureExtensionMethod);
if ((flags & ParamFlags.This) != 0)
{
mod = this.AddError(mod, ErrorCode.ERR_DupParamMod, SyntaxKindFacts.GetText(SyntaxKind.ThisKeyword));
}
else if ((flags & ParamFlags.Params) != 0)
{
mod = this.AddError(mod, ErrorCode.ERR_BadParamModThis);
}
else
{
flags |= ParamFlags.This;
}
}
if (mod.Kind == SyntaxKind.FinalKeyword)
{
flags |= ParamFlags.Final;
}
//else if (mod.Kind == SyntaxKind.ParamsKeyword)
//{
// if ((flags & ParamFlags.Params) != 0)
// {
// mod = this.AddError(mod, ErrorCode.ERR_DupParamMod, SyntaxKindFacts.GetText(SyntaxKind.ParamsKeyword));
// }
// else if ((flags & ParamFlags.This) != 0)
// {
// mod = this.AddError(mod, ErrorCode.ERR_BadParamModThis);
// }
// else if ((flags & (ParamFlags.Ref | ParamFlags.Out | ParamFlags.This)) != 0)
// {
// mod = this.AddError(mod, ErrorCode.ERR_MultiParamMod);
// }
// else
// {
// flags |= ParamFlags.Params;
// }
//}
}
modifiers.Add(mod);
continue;
}
if (allowFieldModifiers)
{
var newFieldMod = GetFieldModifier(this.CurrentToken);
if (newFieldMod != SyntaxModifier.None)
{
var modTok = this.EatToken();
if (newFieldMod == SyntaxModifier.Static)
{
if ((fieldMods & SyntaxModifier.Static) == 0)
{
modTok = this.AddError(modTok, ErrorCode.ERR_StaticParamMod);
}
}
else
{
ReportDuplicateModifiers(ref modTok, newFieldMod, fieldMods, ref seenNoDuplicates, ref seenNoAccessibilityDuplicates);
}
fieldMods |= newFieldMod;
modifiers.Add(modTok);
continue;
}
}
break;
}
if (fieldMods != 0 && fieldMods != SyntaxModifier.Static && ((fieldMods & AccessModifiers) == 0))
{
for (int i = 0; i < modifiers.Count; i++)
{
var mod = GetFieldModifier((SyntaxToken)modifiers[i]);
if (mod != SyntaxModifier.None && mod != SyntaxModifier.Static)
{
Debug.Assert((fieldMods & AccessModifiers) == 0);
if ((fieldMods & AccessModifiers) == 0)
{
modifiers[i] = this.AddError(modifiers[i], ErrorCode.ERR_ParamMissingAccessMod);
}
break;
}
}
}
}
private bool IsPossibleNewExpression()
{
Debug.Assert(this.CurrentToken.Kind == SyntaxKind.NewKeyword);
// skip new
SyntaxToken nextToken = PeekToken(1);
// new { }
// new [ ]
switch (nextToken.Kind)
{
case SyntaxKind.OpenBraceToken:
case SyntaxKind.OpenBracketToken:
return(true);
}
//
// Declaration with new modifier vs. new expression
// Parse it as an expression if the type is not followed by an identifier or this keyword.
//
// Member declarations:
// new T Idf ...
// new T this ...
// new partial Idf ("partial" as a type name)
// new partial this ("partial" as a type name)
// new partial T Idf
// new partial T this
// new <modifier>
// new <class|interface|struct|enum>
// new partial <class|interface|struct|enum>
//
// New expressions:
// new T []
// new T { }
// new <non-type>
//
if (SyntaxKindFacts.GetBaseTypeDeclarationKind(nextToken.Kind) != SyntaxKind.None)
{
return(false);
}
SyntaxModifier modifier = GetModifier(nextToken);
if (modifier != SyntaxModifier.None)
{
return(false);
}
bool?typedIdentifier = IsPossibleTypedIdentifierStart(nextToken, PeekToken(2), allowThisKeyword: true);
if (typedIdentifier != null)
{
// new Idf Idf
// new Idf .
// new partial T
// new partial .
return(!typedIdentifier.Value);
}
var resetPoint = this.GetResetPoint();
try
{
// skips new keyword
EatToken();
ScanTypeFlags st = this.ScanType();
return(!IsPossibleMemberName() || st == ScanTypeFlags.NotType);
}
finally
{
this.Reset(ref resetPoint);
this.Release(ref resetPoint);
}
}
