internal static void VerifyArguments(Diagnostic diagnostic, Compilation compilationOpt, Func <Diagnostic, bool> isSupportedDiagnostic) { if (diagnostic is DiagnosticWithInfo) { // Compiler diagnostic, skip validations. return; } if (diagnostic == null) { throw new ArgumentNullException(nameof(diagnostic)); } if (compilationOpt != null) { VerifyDiagnosticLocationsInCompilation(diagnostic, compilationOpt); } if (!isSupportedDiagnostic(diagnostic)) { throw new ArgumentException(string.Format(CodeAnalysisResources.UnsupportedDiagnosticReported, diagnostic.Id), nameof(diagnostic)); } if (!UnicodeCharacterUtilities.IsValidIdentifier(diagnostic.Id)) { // Disallow invalid diagnostic IDs. // Note that the parsing logic in Csc/Vbc MSBuild tasks to decode command line compiler output relies on diagnostics having a valid ID. // See https://github.com/dotnet/roslyn/issues/4376 for details. throw new ArgumentException(string.Format(CodeAnalysisResources.InvalidDiagnosticIdReported, diagnostic.Id), nameof(diagnostic)); } }
private void GenerateMetadataNodes( MetadataNode parentNode, string nodeName, OrderPreservingMultiDictionary <string, MetadataDefinition> .ValueSet definitionsWithSameName) { if (!UnicodeCharacterUtilities.IsValidIdentifier(nodeName)) { return; } var childNode = MetadataNode.Allocate(nodeName); _parentToChildren.Add(parentNode, childNode); // Add all child members var definitionMap = OrderPreservingMultiDictionary <string, MetadataDefinition> .GetInstance(); try { foreach (var definition in definitionsWithSameName) { LookupMetadataDefinitions(definition, definitionMap); } foreach (var kvp in definitionMap) { GenerateMetadataNodes(childNode, kvp.Key, kvp.Value); } } finally { definitionMap.Free(); } }
private static void GenerateMetadataNodes( MetadataReader reader, string name, int parentIndex, OrderPreservingMultiDictionary <string, MetadataDefinition> .ValueSet definitionsWithSameName, List <Node> unsortedNodes) { var node = new Node(name, parentIndex); var nodeIndex = unsortedNodes.Count; unsortedNodes.Add(node); // Add all child members var definitionMap = OrderPreservingMultiDictionary <string, MetadataDefinition> .GetInstance(); try { foreach (var definition in definitionsWithSameName) { LookupMetadataDefinitions(reader, definition, definitionMap); } foreach (var kvp in definitionMap) { if (UnicodeCharacterUtilities.IsValidIdentifier(kvp.Key)) { GenerateMetadataNodes(reader, kvp.Key, nodeIndex, kvp.Value, unsortedNodes); } } } finally { definitionMap.Free(); } }
private void GenerateMetadataNodes( MetadataNode parentNode, string nodeName, OrderPreservingMultiDictionary < string, MetadataDefinition > .ValueSet definitionsWithSameName ) { if (!UnicodeCharacterUtilities.IsValidIdentifier(nodeName)) { return; } var childNode = MetadataNode.Allocate(nodeName); _parentToChildren.Add(parentNode, childNode); // Add all child members var definitionMap = OrderPreservingMultiDictionary < string, MetadataDefinition > .GetInstance(); try { foreach (var definition in definitionsWithSameName) { if (definition.Kind == MetadataDefinitionKind.Member) { // We need to support having multiple methods with same name but different receiver type. _extensionMethodToParameterTypeInfo.Add( childNode, definition.ReceiverTypeInfo ); } LookupMetadataDefinitions(definition, definitionMap); } foreach (var(name, definitions) in definitionMap) { GenerateMetadataNodes(childNode, name, definitions); } } finally { definitionMap.Free(); } }
/// <summary> /// Old VS projects had some pretty messed-up looking values for the /// "DefineConstants" property. It worked fine in the IDE, because it /// effectively munged up the string so that it ended up being valid for /// the compiler. We do the equivalent munging here now. /// /// Basically, we take the incoming string, and split it on comma/semicolon/space. /// Then we look at the resulting list of strings, and remove any that are /// illegal identifiers, and pass the remaining ones through to the compiler. /// /// Note that CSharp doesn't support assigning a value to the constants ... in /// other words, a constant is either defined or not defined ... it can't have /// an actual value. /// </summary> internal static string?GetDefineConstantsSwitch( string?originalDefineConstants, TaskLoggingHelper log ) { if (originalDefineConstants == null) { return(null); } StringBuilder finalDefineConstants = new StringBuilder(); // Split the incoming string on comma/semicolon/space. string[] allIdentifiers = originalDefineConstants.Split(new char[] { ',', ';', ' ' }); // Loop through all the parts, and for the ones that are legal C# identifiers, // add them to the outgoing string. foreach (string singleIdentifier in allIdentifiers) { if (UnicodeCharacterUtilities.IsValidIdentifier(singleIdentifier)) { // Separate them with a semicolon if there's something already in // the outgoing string. if (finalDefineConstants.Length > 0) { finalDefineConstants.Append(";"); } finalDefineConstants.Append(singleIdentifier); } else if (singleIdentifier.Length > 0) { log.LogWarningWithCodeFromResources( "Csc_InvalidParameterWarning", "/define:", singleIdentifier ); } } if (finalDefineConstants.Length > 0) { return(finalDefineConstants.ToString()); } else { // We wouldn't want to pass in an empty /define: switch on the csc.exe command-line. return(null); } }
private static void GenerateMetadataNodes( MetadataReader reader, NamespaceDefinition globalNamespace, List <Node> unsortedNodes) { var definitionMap = OrderPreservingMultiDictionary <string, MetadataDefinition> .GetInstance(); try { LookupMetadataDefinitions(reader, globalNamespace, definitionMap); foreach (var kvp in definitionMap) { if (UnicodeCharacterUtilities.IsValidIdentifier(kvp.Key)) { GenerateMetadataNodes(reader, kvp.Key, 0 /*index of root node*/, kvp.Value, unsortedNodes); } } } finally { definitionMap.Free(); } }
/// <summary> /// Check that the name is a valid identifier. /// </summary> public static bool IsValidIdentifier(string name) { return(UnicodeCharacterUtilities.IsValidIdentifier(name)); }
/// <summary> /// Check that the name is a valid identifier. /// </summary> public static bool IsValidIdentifier([NotNullWhen(true)] string?name) { return(UnicodeCharacterUtilities.IsValidIdentifier(name)); }