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); } }