private Token ScanIdentifierAfterStartCharacter(bool verbatim) { // Assert the offset is immediately following the start character. Debug.Assert(_offset > 0); Debug.Assert(UnicodeCharacterUtilities.IsIdentifierStartCharacter(_text[_offset - 1])); Debug.Assert(_offset == 1 || !UnicodeCharacterUtilities.IsIdentifierPartCharacter(_text[_offset - 2])); int length = _text.Length; int start = _offset - 1; while ((_offset < length) && UnicodeCharacterUtilities.IsIdentifierPartCharacter(_text[_offset])) { _offset++; } var text = _text.Substring(start, _offset - start); var keywordKind = verbatim ? SyntaxKind.None : SyntaxFacts.GetKeywordKind(text); if (keywordKind == SyntaxKind.None) { return(new Token(TokenKind.Identifier, text)); } return(new Token(TokenKind.Keyword, text, keywordKind)); }
// Returns the number of characters in the // identifier starting at the current offset. private int ScanIdentifier() { int length = _text.Length - _offset; if (length > 0 && UnicodeCharacterUtilities.IsIdentifierStartCharacter(_text[_offset])) { int n = 1; while (n < length && UnicodeCharacterUtilities.IsIdentifierPartCharacter(_text[_offset + n])) { n++; } return(n); } return(0); }
public virtual string Process(IReadOnlyDictionary <string, IValueForm>?forms, string value) { const char invalidCharacterReplacement = '_'; value = value ?? throw new ArgumentNullException(nameof(value)); value = value.Trim(); StringBuilder safeValueStr = new StringBuilder(value.Length); for (int i = 0; i < value.Length; i++) { if (i < value.Length - 1 && char.IsSurrogatePair(value[i], value[i + 1])) { safeValueStr.Append(invalidCharacterReplacement); // Skip both chars that make up this symbol. i++; continue; } bool isFirstCharacterOfIdentifier = safeValueStr.Length == 0 || safeValueStr[safeValueStr.Length - 1] == '.'; bool isValidFirstCharacter = UnicodeCharacterUtilities.IsIdentifierStartCharacter(value[i]); bool isValidPartCharacter = UnicodeCharacterUtilities.IsIdentifierPartCharacter(value[i]); if (isFirstCharacterOfIdentifier && !isValidFirstCharacter && isValidPartCharacter) { // This character cannot be at the beginning, but is good otherwise. Prefix it with something valid. safeValueStr.Append(invalidCharacterReplacement); safeValueStr.Append(value[i]); } else if ((isFirstCharacterOfIdentifier && isValidFirstCharacter) || (!isFirstCharacterOfIdentifier && isValidPartCharacter) || (safeValueStr.Length > 0 && i < value.Length - 1 && value[i] == '.')) { // This character is allowed to be where it is. safeValueStr.Append(value[i]); } else { safeValueStr.Append(invalidCharacterReplacement); } } return(safeValueStr.ToString()); }
/// <summary> /// Returns true if the Unicode character can be a part of a C# identifier. /// </summary> /// <param name="ch">The Unicode character.</param> public static bool IsIdentifierPartCharacter(char ch) { return(UnicodeCharacterUtilities.IsIdentifierPartCharacter(ch)); }
/// <summary> /// Makes sure that the string at least somewhat resembles the correct form. /// Does not check validity on class or method identifiers /// Example line: /// at ConsoleApp4.MyClass.ThrowAtOne(p1, p2) /// |-------------------||--------||-------| /// Class Method Args /// </summary> /// <remarks> /// See https://docs.microsoft.com/en-us/dotnet/api/system.environment.stacktrace for more information /// on expected stacktrace form. At time of writing, this is based on the following "ToString" implementation in the runtime: /// https://github.com/dotnet/runtime/blob/72d643d05ab23888f30a57d447154e36f979f3d1/src/libraries/System.Private.CoreLib/src/System/Diagnostics/StackTrace.cs#L206 /// </remarks> public static bool TryParseMethodSignature(ReadOnlySpan <char> line, out TextSpan classSpan, out TextSpan methodSpan, out TextSpan argsSpan) { var state = new ParseStateMachine(); for (var i = 0; i < line.Length; i++) { if (state.CurrentParsingSpan == CurrentParsingSpan.Finished) { break; } var c = line[i]; state.CurrentSpanLength++; // // Every if statement should be a branch and always end with a "continue" statement. // It is cumbersome to read this as a switch statement, especially given that not all branches // are just switches on a character. If new arms are added, follow the general rule that // all top if statements should not continue execution after they exit. // // // When starting to parse an identifier we want the first character to be valid. Arguments will // be an exception here so don't check validity of those characters for the first item // if (state.CurrentSpanLength == 1 && state.CurrentParsingSpan != CurrentParsingSpan.Arguments) { // When starting to parse an identifier we want the first character to be valid if (!UnicodeCharacterUtilities.IsIdentifierStartCharacter(c)) { state.Reset(); continue; } // If we're starting to parse the type then we want the previous character to either be a space // or this to be the beginning of the string. We don't want to try to have valid identifier starts // as a subword of some text if (i > 0) { var previousChar = line[i - 1]; if (previousChar != ' ') { state.Reset(); continue; } } continue; } if (c == ' ') { if (!state.AllowSpace) { // We encountered a space in an area we don't expect. Reset the state and start trying to parse // the next block as a method signature state.Reset(); } continue; } if (c == '.') { // Dot separators are allowed in the following cases: // 1. We are parsing the fully qualified type portion // 2. We are parsing arguments which could use a dot to fully qualify a type // 3. We are inside of a generic context, which could use dot to fully qualify a type if (state.CurrentParsingSpan == CurrentParsingSpan.Type || state.CurrentParsingSpan == CurrentParsingSpan.Arguments) { // Check that the previous item was a valid identifier character or ] (generic closure) if (i > 0) { var previousChar = line[i - 1]; if (UnicodeCharacterUtilities.IsIdentifierPartCharacter(previousChar) || previousChar == ']') { continue; } } // Either there is no previous character, or the previous character does not allow for a '.' // following it. Reset and continue parsing state.Reset(); continue; } continue; } if (c == '[' || c == '<') { state.GenericDepth++; continue; } if (c == ']' || c == '>') { if (state.GenericDepth == 0) { state.Reset(); } else { state.GenericDepth--; } continue; } if (c == '(') { if (state.CurrentParsingSpan == CurrentParsingSpan.Type) { state.StartParsingArguments(line); } else { // In cases where we encounter a '(' and already are parsing arguments we want // to stop parsing. This could be problematic in cases where the value of a variable // is provided and is a string, but for now we will just fail parsing that. state.Reset(); } continue; } if (c == ')') { // ')' is invalid except for closing the end of the arguments list if (state.CurrentParsingSpan != CurrentParsingSpan.Arguments) { state.Reset(); continue; } // Similar to assuming that '(' will always be considered a start of the argument section, we assume // that ')' will end it. There are cases where this is not true, but for now that's not supported. state.StopParsingArguments(); continue; } if (c == ',') { // Comma is allowed if we are parsing arguments or are currently going through a generic list. // As of now, no validation is done that the comma is valid in this location if (state.CurrentParsingSpan != CurrentParsingSpan.Arguments && state.GenericDepth == 0) { state.Reset(); } continue; } // In cases where we have no explicitly handled a character, our last effort is to make sure // we are only accepting valid identifier characters. Every character that needs to be handled // differently should be before this check if (!UnicodeCharacterUtilities.IsIdentifierPartCharacter(c)) { state.Reset(); continue; } } classSpan = state.TypeSpan; methodSpan = state.MethodSpan; argsSpan = state.ArgumentsSpan; return(state.CurrentParsingSpan == CurrentParsingSpan.Finished && classSpan != default && methodSpan != default && argsSpan != default); }