// Only the compiler creates instances. internal DiagnosticInfo(CommonMessageProvider messageProvider, int errorCode) { _messageProvider = messageProvider; _errorCode = errorCode; _defaultSeverity = messageProvider.GetSeverity(errorCode); _effectiveSeverity = _defaultSeverity; }
// Only the compiler creates instances. internal DiagnosticInfo(CommonMessageProvider messageProvider, int errorCode, params object[] arguments) : this(messageProvider, errorCode) { AssertMessageSerializable(arguments); _arguments = arguments; }
private DiagnosticInfo(DiagnosticInfo original, DiagnosticSeverity overridenSeverity) { _messageProvider = original.MessageProvider; _errorCode = original._errorCode; _defaultSeverity = original.DefaultSeverity; _arguments = original._arguments; _effectiveSeverity = overridenSeverity; }
private static DiagnosticDescriptor CreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider) { var id = messageProvider.GetIdForErrorCode(errorCode); var title = messageProvider.GetTitle(errorCode); var description = messageProvider.GetDescription(errorCode); var messageFormat = messageProvider.GetMessageFormat(errorCode); var helpLink = messageProvider.GetHelpLink(errorCode); var category = messageProvider.GetCategory(errorCode); var customTags = GetCustomTags(defaultSeverity); return new DiagnosticDescriptor(id, title, messageFormat, category, defaultSeverity, isEnabledByDefault: true, description: description, helpLinkUri: helpLink, customTags: customTags); }
public CommonSyntaxAndDeclarationManager( ImmutableArray<SyntaxTree> externalSyntaxTrees, string scriptClassName, SourceReferenceResolver resolver, CommonMessageProvider messageProvider, bool isSubmission) { this.ExternalSyntaxTrees = externalSyntaxTrees; this.ScriptClassName = scriptClassName ?? ""; this.Resolver = resolver; this.MessageProvider = messageProvider; this.IsSubmission = isSubmission; }
internal static StrongNameKeys Create(ImmutableArray<byte> publicKey, CommonMessageProvider messageProvider) { Debug.Assert(!publicKey.IsDefaultOrEmpty); if (MetadataHelpers.IsValidPublicKey(publicKey)) { return new StrongNameKeys(default(ImmutableArray<byte>), publicKey, null, null); } else { return new StrongNameKeys(messageProvider.CreateDiagnostic(messageProvider.ERR_BadCompilationOptionValue, Location.None, nameof(CompilationOptions.CryptoPublicKey), BitConverter.ToString(publicKey.ToArray()))); } }
internal static StrongNameKeys Create(StrongNameProvider providerOpt, string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider) { if (string.IsNullOrEmpty(keyFilePath) && string.IsNullOrEmpty(keyContainerName)) { return None; } if (providerOpt == null) { var diagnostic = GetError(keyFilePath, keyContainerName, new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)), messageProvider); return new StrongNameKeys(diagnostic); } return providerOpt.CreateKeys(keyFilePath, keyContainerName, messageProvider); }
// Only the compiler creates instances. internal DiagnosticInfo(CommonMessageProvider messageProvider, int errorCode, params object[] arguments) : this(messageProvider, errorCode) { Debug.Assert(Array.TrueForAll(arguments, arg => arg != null && (arg is IMessageSerializable || arg.GetType().IsSerializable))); this.arguments = arguments; #if false if (arguments != null) { foreach (var arg in arguments) { Debug.Assert(arg != null, "Diagnostic argument is null"); Debug.Assert(!arg.GetType().IsEnum, "Enum used as diagnostic argument"); } } #endif }
public static bool WritePeToStream( EmitContext context, CommonMessageProvider messageProvider, Func<Stream> getPeStream, PdbWriter nativePdbWriterOpt, string pdbPathOpt, bool allowMissingMethodBodies, bool deterministic, CancellationToken cancellationToken) { // If PDB writer is given, we have to have PDB path. Debug.Assert(nativePdbWriterOpt == null || pdbPathOpt != null); var peWriter = new PeWriter(context.Module, pdbPathOpt, deterministic); var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken); return peWriter.WritePeToStream(mdWriter, getPeStream, nativePdbWriterOpt); }
public static void WritePeToStream( EmitContext context, CommonMessageProvider messageProvider, Stream peStream, PdbWriter nativePdbWriterOpt, bool allowMissingMethodBodies, bool deterministic, CancellationToken cancellationToken) { var peWriter = new PeWriter(context.Module, nativePdbWriterOpt, deterministic); var mdWriter = FullMetadataWriter.Create(context, messageProvider, allowMissingMethodBodies, deterministic, cancellationToken); if (nativePdbWriterOpt != null) { nativePdbWriterOpt.SetMetadataEmitter(mdWriter); } uint entryPointToken; peWriter.WritePeToStream(mdWriter, peStream, nativePdbWriterOpt, out entryPointToken); if (nativePdbWriterOpt != null) { if (entryPointToken != 0) { nativePdbWriterOpt.SetEntryPoint(entryPointToken); } var assembly = context.Module.AsAssembly; if (assembly != null && assembly.Kind == ModuleKind.WindowsRuntimeMetadata) { // Dev12: If compiling to winmdobj, we need to add to PDB source spans of // all types and members for better error reporting by WinMDExp. nativePdbWriterOpt.WriteDefinitionLocations(context.Module.GetSymbolToLocationMap()); } } }
private static DiagnosticDescriptor GetOrCreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider) { return ImmutableInterlocked.GetOrAdd(ref s_errorCodeToDescriptorMap, errorCode, code => CreateDescriptor(code, defaultSeverity, messageProvider)); }
// TODO: change to private protected when available internal static ImmutableArray <PortableExecutableReference> ResolveMetadataReference(CommandLineReference cmdReference, MetadataReferenceResolver metadataResolver, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(metadataResolver != null); Debug.Assert((diagnosticsOpt == null) == (messageProviderOpt == null)); ImmutableArray <PortableExecutableReference> references; try { references = metadataResolver.ResolveReference(cmdReference.Reference, baseFilePath: null, properties: cmdReference.Properties); } catch (Exception e) when(diagnosticsOpt != null && (e is BadImageFormatException || e is IOException)) { var diagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProviderOpt, Location.None, cmdReference.Reference, cmdReference.Properties.Kind); diagnosticsOpt.Add(((DiagnosticWithInfo)diagnostic).Info); return(ImmutableArray <PortableExecutableReference> .Empty); } if (references.IsDefaultOrEmpty && diagnosticsOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.ERR_MetadataFileNotFound, cmdReference.Reference)); return(ImmutableArray <PortableExecutableReference> .Empty); } return(references); }
/// <summary> /// Resolves this command line analyzer path to a <see cref="IEnumerable{IDiagnosticAnalyzer}"/> using given file resolver. /// </summary> /// <param name="fileResolver">The file resolver to use for assembly name and relative path resolution.</param> /// <param name="diagnosticsOpt">Optional diagnostics list for storing diagnostics.</param> /// <param name="messageProviderOpt">Optional <see cref="CommonMessageProvider"/> for generating diagnostics.</param> /// <returns>Returns null if the path is invalid. Otherwise returns the list of analyzer factories from the dll.</returns> internal IEnumerable <IDiagnosticAnalyzer> Resolve(FileResolver fileResolver, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(fileResolver != null); string fullPath = fileResolver.ResolveMetadataFileChecked(this.analyzer, baseFilePath: null); if (fullPath == null) { if (diagnosticsOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.ERR_MetadataFileNotFound, this.analyzer)); } return(null); } else { return(ResolveAnalyzers(fullPath, this.analyzer, diagnosticsOpt, messageProviderOpt)); } }
internal static StrongNameKeys Create(StrongNameProvider providerOpt, string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider) { if (string.IsNullOrEmpty(keyFilePath) && string.IsNullOrEmpty(keyContainerName)) { return(None); } if (providerOpt == null) { Diagnostic diagnostic = GetError(keyFilePath, keyContainerName, new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)), messageProvider); return(new StrongNameKeys(diagnostic)); } return(providerOpt.CreateKeys(keyFilePath, keyContainerName, messageProvider)); }
/// <summary> /// Resolves metadata references stored in <see cref="MetadataReferences"/> using given file resolver and metadata provider. /// If a non-null diagnostic bag <paramref name="diagnosticsOpt"/> is provided, it catches exceptions that may be generated while reading the metadata file and /// reports appropriate diagnostics. /// Otherwise, if <paramref name="diagnosticsOpt"/> is null, the exceptions are unhandled. /// </summary> /// <remarks> /// called by CommonCompiler with diagnostics and message provider /// </remarks> internal IEnumerable <MetadataReference> ResolveMetadataReferences(MetadataReferenceResolver metadataResolver, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(metadataResolver != null); var resolved = new List <MetadataReference>(); this.ResolveMetadataReferences(metadataResolver, diagnosticsOpt, messageProviderOpt, resolved); return(resolved); }
internal static Diagnostic GetError(string keyFilePath, string keyContainerName, object message, CommonMessageProvider messageProvider) { if (keyContainerName != null) { return(GetContainerError(messageProvider, keyContainerName, message)); } else { return(GetKeyFileError(messageProvider, keyFilePath, message)); } }
internal ImmutableArray<DiagnosticAnalyzer> ResolveAnalyzersFromArguments( string language, List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, IAnalyzerAssemblyLoader analyzerLoader) { var analyzerBuilder = ImmutableArray.CreateBuilder<DiagnosticAnalyzer>(); EventHandler<AnalyzerLoadFailureEventArgs> errorHandler = (o, e) => { var analyzerReference = o as AnalyzerFileReference; DiagnosticInfo diagnostic; switch (e.ErrorCode) { case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_UnableToLoadAnalyzer, analyzerReference.FullPath, e.Message); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerCannotBeCreated, e.TypeName, analyzerReference.FullPath, e.Message); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_NoAnalyzerInAssembly, analyzerReference.FullPath); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.None: default: return; } // Filter this diagnostic based on the compilation options so that /nowarn and /warnaserror etc. take effect. diagnostic = messageProvider.FilterDiagnosticInfo(diagnostic, this.CompilationOptions); if (diagnostic != null) { diagnostics.Add(diagnostic); } }; var resolvedReferences = ArrayBuilder<AnalyzerFileReference>.GetInstance(); foreach (var reference in AnalyzerReferences) { var resolvedReference = ResolveAnalyzerReference(reference, analyzerLoader); if (resolvedReference != null) { resolvedReferences.Add(resolvedReference); // register the reference to the analyzer loader: analyzerLoader.AddDependencyLocation(resolvedReference.FullPath); } else { diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath)); } } // All analyzer references are registered now, we can start loading them: foreach (var resolvedReference in resolvedReferences) { resolvedReference.AnalyzerLoadFailed += errorHandler; resolvedReference.AddAnalyzers(analyzerBuilder, language); resolvedReference.AnalyzerLoadFailed -= errorHandler; } resolvedReferences.Free(); return analyzerBuilder.ToImmutable(); }
private static ReportDiagnostic GetDiagnosticOptionsFromRulesetFile(Dictionary <string, ReportDiagnostic> diagnosticOptions, string resolvedPath, IList <Diagnostic> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(resolvedPath != null); var generalDiagnosticOption = ReportDiagnostic.Default; try { var ruleSet = RuleSet.LoadEffectiveRuleSetFromFile(resolvedPath); generalDiagnosticOption = ruleSet.GeneralDiagnosticOption; foreach (var rule in ruleSet.SpecificDiagnosticOptions) { diagnosticOptions.Add(rule.Key, rule.Value); } } catch (InvalidRuleSetException e) { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(Diagnostic.Create(messageProviderOpt, messageProviderOpt.ERR_CantReadRulesetFile, resolvedPath, e.Message)); } } catch (IOException e) { if (e is FileNotFoundException || e is DirectoryNotFoundException) { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(Diagnostic.Create(messageProviderOpt, messageProviderOpt.ERR_CantReadRulesetFile, resolvedPath, new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.FileNotFound)))); } } else { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(Diagnostic.Create(messageProviderOpt, messageProviderOpt.ERR_CantReadRulesetFile, resolvedPath, e.Message)); } } } return(generalDiagnosticOption); }
internal static ReportDiagnostic GetDiagnosticOptionsFromRulesetFile(Dictionary <string, ReportDiagnostic> diagnosticOptions, string path, string baseDirectory, IList <Diagnostic> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { var resolvedPath = FileUtilities.ResolveRelativePath(path, baseDirectory); if (resolvedPath == null) { if (diagnosticsOpt != null && messageProviderOpt != null) { diagnosticsOpt.Add(Diagnostic.Create(messageProviderOpt, messageProviderOpt.FTL_InputFileNameTooLong, path)); } return(ReportDiagnostic.Default); } return(GetDiagnosticOptionsFromRulesetFile(diagnosticOptions, resolvedPath, diagnosticsOpt, messageProviderOpt)); }
internal override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider) { var keyPair = default(ImmutableArray <byte>); var publicKey = default(ImmutableArray <byte>); string container = null; if (!string.IsNullOrEmpty(keyFilePath)) { try { string resolvedKeyFile = ResolveStrongNameKeyFile(keyFilePath); if (resolvedKeyFile == null) { throw new FileNotFoundException(CodeAnalysisResources.FileNotFound, keyFilePath); } Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile)); ReadKeysFromPath(resolvedKeyFile, out keyPair, out publicKey); } catch (IOException ex) { return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message))); } } else if (!string.IsNullOrEmpty(keyContainerName)) { try { ReadKeysFromContainer(keyContainerName, out publicKey); container = keyContainerName; } catch (IOException ex) { return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message))); } } return(new StrongNameKeys(keyPair, publicKey, container, keyFilePath)); }
internal static Diagnostic Create(CommonMessageProvider messageProvider, int errorCode, params object[] arguments) { return(Create(new DiagnosticInfo(messageProvider, errorCode, arguments))); }
internal static Diagnostic Create(CommonMessageProvider messageProvider, int errorCode) { return(Create(new DiagnosticInfo(messageProvider, errorCode))); }
internal static void DecodeStructLayoutAttribute <TTypeWellKnownAttributeData, TAttributeSyntaxNode, TAttributeData, TAttributeLocation>( ref DecodeWellKnownAttributeArguments <TAttributeSyntaxNode, TAttributeData, TAttributeLocation> arguments, CharSet defaultCharSet, int defaultAutoLayoutSize, CommonMessageProvider messageProvider) where TTypeWellKnownAttributeData : CommonTypeWellKnownAttributeData, new() where TAttributeSyntaxNode : SyntaxNode where TAttributeData : AttributeData { Debug.Assert((object)arguments.AttributeSyntaxOpt != null); TAttributeData attribute = arguments.Attribute; CharSet charSet = (defaultCharSet != Cci.Constants.CharSet_None) ? defaultCharSet : CharSet.Ansi; int? size = null; int? alignment = null; bool hasErrors = false; LayoutKind kind = attribute.CommonConstructorArguments[0].DecodeValue <LayoutKind>(Microsoft.CodeAnalysis.SpecialType.System_Enum); switch (kind) { case LayoutKind.Auto: case LayoutKind.Explicit: case LayoutKind.Sequential: break; default: messageProvider.ReportInvalidAttributeArgument(arguments.Diagnostics, arguments.AttributeSyntaxOpt, 0, attribute); hasErrors = true; break; } int position = 1; foreach (KeyValuePair <string, TypedConstant> namedArg in attribute.CommonNamedArguments) { switch (namedArg.Key) { case "CharSet": charSet = namedArg.Value.DecodeValue <CharSet>(SpecialType.System_Enum); switch (charSet) { case Cci.Constants.CharSet_None: charSet = CharSet.Ansi; break; case CharSet.Ansi: case Cci.Constants.CharSet_Auto: case CharSet.Unicode: break; default: messageProvider.ReportInvalidNamedArgument(arguments.Diagnostics, arguments.AttributeSyntaxOpt, position, attribute.AttributeClass, namedArg.Key); hasErrors = true; break; } break; case "Pack": alignment = namedArg.Value.DecodeValue <int>(SpecialType.System_Int32); // only powers of 2 less or equal to 128 are allowed: if (alignment > 128 || (alignment & (alignment - 1)) != 0) { messageProvider.ReportInvalidNamedArgument(arguments.Diagnostics, arguments.AttributeSyntaxOpt, position, attribute.AttributeClass, namedArg.Key); hasErrors = true; } break; case "Size": size = namedArg.Value.DecodeValue <int>(Microsoft.CodeAnalysis.SpecialType.System_Int32); if (size < 0) { messageProvider.ReportInvalidNamedArgument(arguments.Diagnostics, arguments.AttributeSyntaxOpt, position, attribute.AttributeClass, namedArg.Key); hasErrors = true; } break; } position++; } if (!hasErrors) { if (kind == LayoutKind.Auto && size == null && alignment != null) { // If size is unspecified // C# emits size=0 // VB emits size=1 if the type is a struct, auto-layout and has alignment specified; 0 otherwise size = defaultAutoLayoutSize; } arguments.GetOrCreateData <TTypeWellKnownAttributeData>().SetStructLayout(new TypeLayout(kind, size ?? 0, (byte)(alignment ?? 0)), charSet); } }
internal CommandLineParser(CommonMessageProvider messageProvider, bool isInteractive) { Debug.Assert(messageProvider != null); this.messageProvider = messageProvider; this.isInteractive = isInteractive; }
internal virtual bool ResolveMetadataReferences(MetadataReferenceResolver metadataResolver, List<DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt, List<MetadataReference> resolved) { bool result = true; foreach (CommandLineReference cmdReference in MetadataReferences) { var references = ResolveMetadataReference(cmdReference, metadataResolver, diagnosticsOpt, messageProviderOpt); if (!references.IsDefaultOrEmpty) { resolved.AddRange(references); } else { result = false; if (diagnosticsOpt == null) { // no diagnostic, so leaved unresolved reference in list resolved.Add(new UnresolvedMetadataReference(cmdReference.Reference, cmdReference.Properties)); } } } return result; }
/// <summary> /// Resolves metadata references stored in <see cref="MetadataReferences"/> using given file resolver and metadata provider. /// If a non-null diagnostic bag <paramref name="diagnosticsOpt"/> is provided, it catches exceptions that may be generated while reading the metadata file and /// reports appropriate diagnostics. /// Otherwise, if <paramref name="diagnosticsOpt"/> is null, the exceptions are unhandled. /// </summary> internal IEnumerable <MetadataReference> ResolveMetadataReferences(MetadataReferenceResolver metadataResolver, MetadataReferenceProvider metadataProvider, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(metadataResolver != null); Debug.Assert(metadataProvider != null); foreach (CommandLineReference cmdReference in MetadataReferences) { yield return(ResolveMetadataReference(cmdReference, metadataResolver, metadataProvider, diagnosticsOpt, messageProviderOpt) ?? new UnresolvedMetadataReference(cmdReference.Reference, cmdReference.Properties)); } }
internal static Diagnostic GetKeyFileError(CommonMessageProvider messageProvider, string path, object message) { return(messageProvider.CreateDiagnostic(messageProvider.ERR_PublicKeyFileFailure, Location.None, path, message)); }
internal MetadataReference ResolveMetadataReference(CommandLineReference cmdReference, MetadataReferenceResolver metadataResolver, MetadataReferenceProvider metadataProvider, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(metadataResolver != null); Debug.Assert(metadataProvider != null); Debug.Assert((diagnosticsOpt == null) == (messageProviderOpt == null)); string resolvedPath = metadataResolver.ResolveReference(cmdReference.Reference, baseFilePath: null); if (resolvedPath == null) { if (diagnosticsOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.ERR_MetadataFileNotFound, cmdReference.Reference)); } return(null); } try { return(metadataProvider.GetReference(resolvedPath, cmdReference.Properties)); } catch (Exception e) if (diagnosticsOpt != null && (e is BadImageFormatException || e is IOException)) { var diagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProviderOpt, Location.None, cmdReference.Reference, cmdReference.Properties.Kind); diagnosticsOpt.Add(((DiagnosticWithInfo)diagnostic).Info); return(null); } }
internal static Diagnostic ExceptionToDiagnostic(Exception e, CommonMessageProvider messageProvider, Location location, string display, MetadataImageKind kind) { if (e is BadImageFormatException) { int errorCode = (kind == MetadataImageKind.Assembly) ? messageProvider.ERR_InvalidAssemblyMetadata : messageProvider.ERR_InvalidModuleMetadata; return messageProvider.CreateDiagnostic(errorCode, location, display, e.Message); } var fileNotFound = e as FileNotFoundException; if (fileNotFound != null) { return messageProvider.CreateDiagnostic(messageProvider.ERR_MetadataFileNotFound, location, fileNotFound.FileName ?? string.Empty); } else { int errorCode = (kind == MetadataImageKind.Assembly) ? messageProvider.ERR_ErrorOpeningAssemblyFile : messageProvider.ERR_ErrorOpeningModuleFile; return messageProvider.CreateDiagnostic(errorCode, location, display, e.Message); } }
internal ImmutableArray <IDiagnosticAnalyzer> ResolveAnalyzersFromArguments(List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles) { var builder = ImmutableArray.CreateBuilder <IDiagnosticAnalyzer>(); foreach (var reference in AnalyzerReferences) { var resolvedReference = ResolveAnalyzerReference(reference); if (resolvedReference != null) { resolvedReference.AddAnalyzers(builder, diagnostics, messageProvider); } else { diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath)); } } return(builder.ToImmutable()); }
private ImmutableArray <AdditionalTextFile> ResolveAdditionalFilesFromArguments(List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFilesLogger) { var builder = ImmutableArray.CreateBuilder <AdditionalTextFile>(); foreach (var file in Arguments.AdditionalFiles) { builder.Add(new AdditionalTextFile(file, this)); } return(builder.ToImmutableArray()); }
protected abstract ImmutableArray <DiagnosticAnalyzer> ResolveAnalyzersFromArguments(List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles);
private IEnumerable <IDiagnosticAnalyzer> ResolveAnalyzers(string fullPath, string analyzer, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { // Using Assembly.LoadFrom to load into the Load-From context. This ensures that: // 1 . The analyzer and it's dependencies don't have to be in the probing path of this process // 2 . When multiple assemblies with the same identity are loaded (even from different paths), we return // the same assembly and avoid bloat. This does mean that strong identity for analyzers is important. Type[] types; try { Assembly analyzerAssembly = Assembly.LoadFrom(fullPath); types = analyzerAssembly.GetTypes(); } catch (Exception e) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_UnableToLoadAnalyzer, analyzer, e.Message)); return(null); } var analyzers = new List <IDiagnosticAnalyzer>(); foreach (var type in types) { if (type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IDiagnosticAnalyzer)) && type.IsDefined(typeof(DiagnosticAnalyzerAttribute))) { try { analyzers.Add((IDiagnosticAnalyzer)Activator.CreateInstance(type)); } catch (Exception e) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.WRN_AnalyzerCannotBeCreated, type, analyzer, e.Message)); } } } return(analyzers); }
private static FileStream OpenManifestStream(CommonMessageProvider messageProvider, OutputKind outputKind, CommandLineArguments arguments, List <DiagnosticInfo> errorList) { return(outputKind.IsNetModule() ? null : OpenStream(messageProvider, arguments.Win32Manifest, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Manifest, errorList)); }
internal ImmutableArray <DiagnosticAnalyzer> ResolveAnalyzersFromArguments(string language, List <DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles, IAnalyzerAssemblyLoader analyzerLoader) { var builder = ImmutableArray.CreateBuilder <DiagnosticAnalyzer>(); EventHandler <AnalyzerLoadFailureEventArgs> errorHandler = (o, e) => { var analyzerReference = o as AnalyzerFileReference; DiagnosticInfo diagnostic = null; switch (e.ErrorCode) { case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_UnableToLoadAnalyzer, analyzerReference.FullPath, e.Message); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToCreateAnalyzer: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_AnalyzerCannotBeCreated, e.TypeName, analyzerReference.FullPath, e.Message); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.NoAnalyzers: diagnostic = new DiagnosticInfo(messageProvider, messageProvider.WRN_NoAnalyzerInAssembly, analyzerReference.FullPath); break; case AnalyzerLoadFailureEventArgs.FailureErrorCode.None: default: return; } // Filter this diagnostic based on the compilation options so that /nowarn and /warnaserror etc. take effect. diagnostic = messageProvider.FilterDiagnosticInfo(diagnostic, this.CompilationOptions); if (diagnostic != null) { diagnostics.Add(diagnostic); } }; foreach (var reference in AnalyzerReferences) { var resolvedReference = ResolveAnalyzerReference(reference, analyzerLoader); if (resolvedReference != null) { resolvedReference.AnalyzerLoadFailed += errorHandler; resolvedReference.AddAnalyzers(builder, language); resolvedReference.AnalyzerLoadFailed -= errorHandler; } else { diagnostics.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_MetadataFileNotFound, reference.FilePath)); } } return(builder.ToImmutable()); }
internal static DiagnosticInfo ToFileReadDiagnostics(CommonMessageProvider messageProvider, Exception e, string filePath) { DiagnosticInfo diagnosticInfo; if (e is FileNotFoundException || e.GetType().Name == "DirectoryNotFoundException") { diagnosticInfo = new DiagnosticInfo(messageProvider, messageProvider.ERR_FileNotFound, filePath); } else if (e is InvalidDataException) { diagnosticInfo = new DiagnosticInfo(messageProvider, messageProvider.ERR_BinaryFile, filePath); } else { diagnosticInfo = new DiagnosticInfo(messageProvider, messageProvider.ERR_NoSourceFile, filePath, e.Message); } return diagnosticInfo; }
internal static DiagnosticDescriptor GetDescriptor(int errorCode, CommonMessageProvider messageProvider) { var defaultSeverity = messageProvider.GetSeverity(errorCode); return GetOrCreateDescriptor(errorCode, defaultSeverity, messageProvider); }
protected virtual ImmutableArray<AdditionalTextFile> ResolveAdditionalFilesFromArguments(List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFilesLogger) { var builder = ImmutableArray.CreateBuilder<AdditionalTextFile>(); foreach (var file in Arguments.AdditionalFiles) { builder.Add(new AdditionalTextFile(file, this)); } return builder.ToImmutableArray(); }
internal virtual bool ResolveMetadataReferences(MetadataReferenceResolver metadataResolver, List <DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt, List <MetadataReference> resolved) { bool result = true; foreach (CommandLineReference cmdReference in MetadataReferences) { var references = ResolveMetadataReference(cmdReference, metadataResolver, diagnosticsOpt, messageProviderOpt); if (!references.IsDefaultOrEmpty) { resolved.AddRange(references); } else { result = false; if (diagnosticsOpt == null) { // no diagnostic, so leaved unresolved reference in list resolved.Add(new UnresolvedMetadataReference(cmdReference.Reference, cmdReference.Properties)); } } } return(result); }
private static Stream OpenManifestStream(CommonMessageProvider messageProvider, OutputKind outputKind, CommandLineArguments arguments, List<DiagnosticInfo> errorList) { return outputKind.IsNetModule() ? null : OpenStream(messageProvider, arguments.Win32Manifest, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Manifest, errorList); }
/// <summary> /// Resolves metadata references stored in <see cref="MetadataReferences"/> using given file resolver and metadata provider. /// If a non-null diagnostic bag <paramref name="diagnosticsOpt"/> is provided, it catches exceptions that may be generated while reading the metadata file and /// reports appropriate diagnostics. /// Otherwise, if <paramref name="diagnosticsOpt"/> is null, the exceptions are unhandled. /// </summary> /// <remarks> /// called by CommonCompiler with diagnostics and message provider /// </remarks> internal IEnumerable<MetadataReference> ResolveMetadataReferences(MetadataReferenceResolver metadataResolver, List<DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(metadataResolver != null); var resolved = new List<MetadataReference>(); this.ResolveMetadataReferences(metadataResolver, diagnosticsOpt, messageProviderOpt, resolved); return resolved; }
private static string ResolveRelativePath(CommonMessageProvider messageProvider, string path, string baseDirectory, IList<DiagnosticInfo> errors) { string fullPath = FileUtilities.ResolveRelativePath(path, baseDirectory); if (fullPath == null) { errors.Add(new DiagnosticInfo(messageProvider, messageProvider.FTL_InputFileNameTooLong, path)); } return fullPath; }
internal static ImmutableArray<PortableExecutableReference> ResolveMetadataReference(CommandLineReference cmdReference, MetadataReferenceResolver metadataResolver, List<DiagnosticInfo> diagnosticsOpt, CommonMessageProvider messageProviderOpt) { Debug.Assert(metadataResolver != null); Debug.Assert((diagnosticsOpt == null) == (messageProviderOpt == null)); ImmutableArray<PortableExecutableReference> references; try { references = metadataResolver.ResolveReference(cmdReference.Reference, baseFilePath: null, properties: cmdReference.Properties); } catch (Exception e) when (diagnosticsOpt != null && (e is BadImageFormatException || e is IOException)) { var diagnostic = PortableExecutableReference.ExceptionToDiagnostic(e, messageProviderOpt, Location.None, cmdReference.Reference, cmdReference.Properties.Kind); diagnosticsOpt.Add(((DiagnosticWithInfo)diagnostic).Info); return ImmutableArray<PortableExecutableReference>.Empty; } if (references.IsDefaultOrEmpty && diagnosticsOpt != null) { diagnosticsOpt.Add(new DiagnosticInfo(messageProviderOpt, messageProviderOpt.ERR_MetadataFileNotFound, cmdReference.Reference)); return ImmutableArray<PortableExecutableReference>.Empty; } return references; }
internal static Diagnostic GetContainerError(CommonMessageProvider messageProvider, string name, object message) { return messageProvider.CreateDiagnostic(messageProvider.ERR_PublicKeyContainerFailure, Location.None, name, message); }
// Only the compiler creates instances. internal DiagnosticInfo(CommonMessageProvider messageProvider, int errorCode) { this.messageProvider = messageProvider; this.errorCode = errorCode; }
internal static Diagnostic GetContainerError(CommonMessageProvider messageProvider, string name, object message) { return(messageProvider.CreateDiagnostic(messageProvider.ERR_PublicKeyContainerFailure, Location.None, name, message)); }
protected abstract ImmutableArray<DiagnosticAnalyzer> ResolveAnalyzersFromArguments(List<DiagnosticInfo> diagnostics, CommonMessageProvider messageProvider, TouchedFileLogger touchedFiles);
// Only the compiler creates instances. internal DiagnosticInfo(CommonMessageProvider messageProvider, bool isWarningAsError, int errorCode, params object[] arguments) : this(messageProvider, errorCode, arguments) { Debug.Assert(!isWarningAsError || messageProvider.GetSeverity(errorCode) == DiagnosticSeverity.Warning); this.isWarningAsError = isWarningAsError; }
// internal for testing internal static Stream GetWin32ResourcesInternal(CommonMessageProvider messageProvider, CommandLineArguments arguments, Compilation compilation, out IEnumerable<DiagnosticInfo> errors) { List<DiagnosticInfo> errorList = new List<DiagnosticInfo>(); errors = errorList; if (arguments.Win32ResourceFile != null) { return OpenStream(messageProvider, arguments.Win32ResourceFile, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Resource, errorList); } using (Stream manifestStream = OpenManifestStream(messageProvider, compilation.Options.OutputKind, arguments, errorList)) { using (Stream iconStream = OpenStream(messageProvider, arguments.Win32Icon, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Icon, errorList)) { try { return compilation.CreateDefaultWin32Resources(true, arguments.NoWin32Manifest, manifestStream, iconStream); } catch (ResourceException ex) { errorList.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_ErrorBuildingWin32Resource, ex.Message)); } catch (OverflowException ex) { errorList.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_ErrorBuildingWin32Resource, ex.Message)); } } } return null; }
internal CommandLineParser(CommonMessageProvider messageProvider, bool isScriptCommandLineParser) { RoslynDebug.Assert(messageProvider != null); _messageProvider = messageProvider; IsScriptCommandLineParser = isScriptCommandLineParser; }
private static Stream OpenStream(CommonMessageProvider messageProvider, string path, string baseDirectory, int errorCode, IList<DiagnosticInfo> errors) { if (path == null) { return null; } string fullPath = ResolveRelativePath(messageProvider, path, baseDirectory, errors); if (fullPath == null) { return null; } try { return PortableShim.FileStream.Create(fullPath, PortableShim.FileMode.Open, PortableShim.FileAccess.Read); } catch (Exception ex) { errors.Add(new DiagnosticInfo(messageProvider, errorCode, fullPath, ex.Message)); } return null; }
internal static DiagnosticDescriptor GetDescriptor(int errorCode, CommonMessageProvider messageProvider) { var defaultSeverity = messageProvider.GetSeverity(errorCode); return(GetOrCreateDescriptor(errorCode, defaultSeverity, messageProvider)); }
internal static Diagnostic GetError(string keyFilePath, string keyContainerName, object message, CommonMessageProvider messageProvider) { if (keyContainerName != null) { return GetContainerError(messageProvider, keyContainerName, message); } else { return GetKeyFileError(messageProvider, keyFilePath, message); } }
private static DiagnosticDescriptor GetOrCreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider) { return(ImmutableInterlocked.GetOrAdd(ref s_errorCodeToDescriptorMap, errorCode, code => CreateDescriptor(code, defaultSeverity, messageProvider))); }
internal static Diagnostic GetKeyFileError(CommonMessageProvider messageProvider, string path, object message) { return messageProvider.CreateDiagnostic(messageProvider.ERR_PublicKeyFileFailure, Location.None, path, message); }
private static DiagnosticDescriptor CreateDescriptor(int errorCode, DiagnosticSeverity defaultSeverity, CommonMessageProvider messageProvider) { var id = messageProvider.GetIdForErrorCode(errorCode); var title = messageProvider.GetTitle(errorCode); var description = messageProvider.GetDescription(errorCode); var messageFormat = messageProvider.GetMessageFormat(errorCode); var helpLink = messageProvider.GetHelpLink(errorCode); var category = messageProvider.GetCategory(errorCode); var customTags = GetCustomTags(defaultSeverity); return(new DiagnosticDescriptor(id, title, messageFormat, category, defaultSeverity, isEnabledByDefault: true, description: description, helpLinkUri: helpLink, customTags: customTags)); }
internal CommandLineParser(CommonMessageProvider messageProvider, bool isScriptRunner) { Debug.Assert(messageProvider != null); _messageProvider = messageProvider; IsScriptRunner = isScriptRunner; }
internal abstract StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider);
internal override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, CommonMessageProvider messageProvider) { var keyPair = default(ImmutableArray<byte>); var publicKey = default(ImmutableArray<byte>); string container = null; if (!string.IsNullOrEmpty(keyFilePath)) { try { string resolvedKeyFile = ResolveStrongNameKeyFile(keyFilePath); if (resolvedKeyFile == null) { throw new FileNotFoundException(CodeAnalysisResources.FileNotFound, keyFilePath); } Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile)); ReadKeysFromPath(resolvedKeyFile, out keyPair, out publicKey); } catch (IOException ex) { return new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)); } } else if (!string.IsNullOrEmpty(keyContainerName)) { try { ReadKeysFromContainer(keyContainerName, out publicKey); container = keyContainerName; } catch (IOException ex) { return new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)); } } return new StrongNameKeys(keyPair, publicKey, container, keyFilePath); }
internal CustomObsoleteDiagnosticInfo(CommonMessageProvider messageProvider, int errorCode, ObsoleteAttributeData data, params object[] arguments) : base(messageProvider, errorCode, arguments) { Data = data; }