/// <summary> /// Create a <see cref="StrongNameKeys"/> for the provided information. /// </summary> internal abstract StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, bool hasCounterSignature, CommonMessageProvider messageProvider);
internal static StrongNameKeys Create(ImmutableArray <byte> publicKey, RSAParameters?privateKey, bool hasCounterSignature, CommonMessageProvider messageProvider)
{
Debug.Assert(!publicKey.IsDefaultOrEmpty);
if (MetadataHelpers.IsValidPublicKey(publicKey))
{
return(new StrongNameKeys(default(ImmutableArray <byte>), publicKey, privateKey, null, null, hasCounterSignature));
}
else
{
return(new StrongNameKeys(messageProvider.CreateDiagnostic(messageProvider.ERR_BadCompilationOptionValue, Location.None,
nameof(CompilationOptions.CryptoPublicKey), BitConverter.ToString(publicKey.ToArray()))));
}
}
internal CommandLineParser(CommonMessageProvider messageProvider, bool isScriptCommandLineParser)
{
Debug.Assert(messageProvider != null);
_messageProvider = messageProvider;
IsScriptCommandLineParser = isScriptCommandLineParser;
}
internal static Diagnostic GetContainerError(CommonMessageProvider messageProvider, string name, object message)
{
return(messageProvider.CreateDiagnostic(messageProvider.ERR_PublicKeyContainerFailure, Location.None, name, message));
}
internal static Diagnostic GetKeyFileError(CommonMessageProvider messageProvider, string path, object message)
{
return(messageProvider.CreateDiagnostic(messageProvider.ERR_PublicKeyFileFailure, Location.None, path, message));
}
internal static StrongNameKeys Create(StrongNameProvider providerOpt, string keyFilePath, string keyContainerName, bool hasCounterSignature, 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, hasCounterSignature, 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));
}
}
internal static ReportDiagnostic GetDiagnosticOptionsFromRulesetFile(string rulesetFileFullPath, out Dictionary <string, ReportDiagnostic> diagnosticOptions, IList <Diagnostic> diagnosticsOpt, CommonMessageProvider messageProviderOpt)
{
diagnosticOptions = new Dictionary <string, ReportDiagnostic>();
if (rulesetFileFullPath == null)
{
return(ReportDiagnostic.Default);
}
return(GetDiagnosticOptionsFromRulesetFile(diagnosticOptions, rulesetFileFullPath, diagnosticsOpt, messageProviderOpt));
}
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.GetType().Name == "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 override StrongNameKeys CreateKeys(string keyFilePath, string keyContainerName, bool hasCounterSignature, CommonMessageProvider messageProvider)
{
var keyPair = default(ImmutableArray <byte>);
var publicKey = default(ImmutableArray <byte>);
string container = null;
if (!string.IsNullOrEmpty(keyFilePath))
{
try
{
string resolvedKeyFile = ResolveStrongNameKeyFile(keyFilePath, FileSystem, _keyFileSearchPaths);
if (resolvedKeyFile == null)
{
return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, CodeAnalysisResources.FileNotFound)));
}
Debug.Assert(PathUtilities.IsAbsolute(resolvedKeyFile));
var fileContent = ImmutableArray.Create(FileSystem.ReadAllBytes(resolvedKeyFile));
return(StrongNameKeys.CreateHelper(fileContent, keyFilePath, hasCounterSignature));
}
catch (Exception ex)
{
return(new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)));
}
}
else if (!string.IsNullOrEmpty(keyContainerName))
{
try
{
ReadKeysFromContainer(keyContainerName, out publicKey);
container = keyContainerName;
}
catch (ClrStrongNameMissingException)
{
return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName,
new CodeAnalysisResourcesLocalizableErrorArgument(nameof(CodeAnalysisResources.AssemblySigningNotSupported)))));
}
catch (Exception ex)
{
return(new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)));
}
}
return(new StrongNameKeys(keyPair, publicKey, privateKey: null, container, keyFilePath, hasCounterSignature));
}
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());
}
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 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>
/// <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);
}