1307 lines
55 KiB
C#
1307 lines
55 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="AssemblyBuilder.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
namespace System.Web.Compilation {
|
|
|
|
using System;
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Security;
|
|
using System.Security.Cryptography;
|
|
using System.Security.Permissions;
|
|
using System.Text;
|
|
using System.Web.Configuration;
|
|
using System.Web.Hosting;
|
|
using System.Web.Management;
|
|
using System.Web.Security.Cryptography;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
|
|
/*
|
|
* This class is used to handle a single compilation using a CodeDom compiler.
|
|
* It is instantiated via CompilerType.CreateAssemblyBuilder.
|
|
*/
|
|
public class AssemblyBuilder {
|
|
|
|
private CompilationSection _compConfig;
|
|
|
|
// CodeChecksumPragma.ChecksumAlgorithmId takes this GUID to represent a SHA1 hash of the file contents
|
|
// See: http://msdn.microsoft.com/en-us/library/system.codedom.codechecksumpragma.checksumalgorithmid.aspx
|
|
private static readonly Guid s_codeChecksumSha1Id = new Guid(0xff1816ec, 0xaa5e, 0x4d10, 0x87, 0xf7, 0x6f, 0x49, 0x63, 0x83, 0x34, 0x60);
|
|
|
|
// List of BuildProviders involved in this compilation
|
|
// The key is either a virtual path, or the BuildProvider itself if
|
|
// it doesn't give us a virtual path.
|
|
// The value is the BuildProvider.
|
|
private Hashtable _buildProviders = new Hashtable(StringComparer.OrdinalIgnoreCase);
|
|
|
|
internal ICollection BuildProviders {
|
|
get { return _buildProviders.Values; }
|
|
}
|
|
|
|
// List of physical source files to be compiled
|
|
private StringSet _sourceFiles = new StringSet();
|
|
|
|
// CodeCompileUnit to hold various top level things we need to generate
|
|
private CodeCompileUnit _miscCodeCompileUnit;
|
|
|
|
// List of physical embedded resource files to be compiled
|
|
private StringSet _embeddedResourceFiles;
|
|
|
|
// The set of assemblies that we will be linked with
|
|
private AssemblySet _initialReferencedAssemblies;
|
|
|
|
// The additional set of assemblies that we will be linked with, and that are
|
|
// requested by various BuildProviders. We need to keep them separate to avoid
|
|
// having BuildProviders see assemblies that were requested by earlier providers,
|
|
// which would lead to unpredictable behavior (since the order is arbitrary)
|
|
private AssemblySet _additionalReferencedAssemblies;
|
|
|
|
internal CodeDomProvider _codeProvider;
|
|
|
|
private Hashtable _buildProviderToSourceFileMap;
|
|
|
|
// The type of CodeDom compiler (i.e. language, flags)
|
|
private CompilerType _compilerType;
|
|
|
|
internal Type CodeDomProviderType {
|
|
get { return _compilerType.CodeDomProviderType; }
|
|
}
|
|
|
|
// Used to generate fast Type factories
|
|
private ObjectFactoryCodeDomTreeGenerator _objectFactoryGenerator;
|
|
|
|
private StringResourceBuilder _stringResourceBuilder;
|
|
internal StringResourceBuilder StringResourceBuilder {
|
|
get {
|
|
if (_stringResourceBuilder == null)
|
|
_stringResourceBuilder = new StringResourceBuilder();
|
|
|
|
return _stringResourceBuilder;
|
|
}
|
|
}
|
|
|
|
// Used to create temporary source files
|
|
private TempFileCollection _tempFiles = new TempFileCollection(HttpRuntime.CodegenDirInternal);
|
|
private int _fileCount;
|
|
|
|
private string _cultureName;
|
|
internal string CultureName {
|
|
get { return _cultureName; }
|
|
set { _cultureName = value; }
|
|
}
|
|
|
|
private string _outputAssemblyName;
|
|
private string OutputAssemblyName {
|
|
get {
|
|
if (_outputAssemblyName == null) {
|
|
// If we don't have the assembly name, we should never have a culture
|
|
Debug.Assert(CultureName == null);
|
|
|
|
// If the assembly name was not specified, use a generated one based on the TempFileCollection.
|
|
// But prefix it with a fixed token, to make it easier to recognize the assembly (DevDiv 36625)
|
|
string basePath = _tempFiles.BasePath;
|
|
string baseFileName = Path.GetFileName(basePath);
|
|
_outputAssemblyName = BuildManager.WebAssemblyNamePrefix + baseFileName;
|
|
}
|
|
|
|
return _outputAssemblyName;
|
|
}
|
|
}
|
|
|
|
private int _maxBatchSize;
|
|
private long _maxBatchGeneratedFileSize;
|
|
private long _totalFileLength;
|
|
|
|
private CaseInsensitiveStringSet _registeredTypeNames;
|
|
internal bool ContainsTypeNames(ICollection typeNames) {
|
|
if (_registeredTypeNames != null && typeNames != null) {
|
|
foreach (String typeName in typeNames) {
|
|
if (_registeredTypeNames.Contains(typeName)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal void AddTypeNames(ICollection typeNames) {
|
|
if (typeNames == null) {
|
|
return;
|
|
}
|
|
|
|
if (_registeredTypeNames == null) {
|
|
_registeredTypeNames = new CaseInsensitiveStringSet();
|
|
}
|
|
|
|
_registeredTypeNames.AddCollection(typeNames);
|
|
}
|
|
|
|
internal AssemblyBuilder(CompilationSection compConfig,
|
|
ICollection referencedAssemblies, CompilerType compilerType, string outputAssemblyName) {
|
|
|
|
_compConfig = compConfig;
|
|
|
|
_outputAssemblyName = outputAssemblyName;
|
|
|
|
// Clone the referenced assemblies
|
|
_initialReferencedAssemblies = AssemblySet.Create(referencedAssemblies);
|
|
|
|
// We need to clone it to avoid modifying the original (VSWhidbey 338935)
|
|
_compilerType = compilerType.Clone();
|
|
|
|
if (BuildManager.PrecompilingWithDebugInfo) {
|
|
// If the precompile flag indicates force debug, always compile as debug
|
|
_compilerType.CompilerParameters.IncludeDebugInformation = true;
|
|
}
|
|
else if (BuildManager.PrecompilingForDeployment) {
|
|
// If we're precompiling the app, never compile in debug mode (VSWhidbey 178377)
|
|
_compilerType.CompilerParameters.IncludeDebugInformation = false;
|
|
}
|
|
else if (DeploymentSection.RetailInternal) {
|
|
// If we're in retail deployment mode, always turn off debug (DevDiv 36396)
|
|
_compilerType.CompilerParameters.IncludeDebugInformation = false;
|
|
}
|
|
else if (_compConfig.AssemblyPostProcessorTypeInternal != null) {
|
|
// If an IAssemblyPostProcessor is registered always compile as debug
|
|
_compilerType.CompilerParameters.IncludeDebugInformation = true;
|
|
}
|
|
|
|
//
|
|
_tempFiles.KeepFiles = _compilerType.CompilerParameters.IncludeDebugInformation;
|
|
|
|
_codeProvider = CompilationUtil.CreateCodeDomProviderNonPublic(
|
|
_compilerType.CodeDomProviderType);
|
|
|
|
_maxBatchSize = _compConfig.MaxBatchSize;
|
|
_maxBatchGeneratedFileSize = _compConfig.MaxBatchGeneratedFileSize * 1024;
|
|
}
|
|
|
|
// Beginning of public contract
|
|
|
|
|
|
/// <devdoc>
|
|
/// Adds an assembly that will be referenced during compilation.
|
|
/// </devdoc>
|
|
public void AddAssemblyReference(Assembly a) {
|
|
if (_additionalReferencedAssemblies == null)
|
|
_additionalReferencedAssemblies = new AssemblySet();
|
|
_additionalReferencedAssemblies.Add(a);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Adds an assembly that will be referenced during compilation. Also adds the
|
|
/// assembly the the ReferencedAssemblies list in the CodeCompileUnit.
|
|
/// </devdoc>
|
|
internal void AddAssemblyReference(Assembly a, CodeCompileUnit ccu) {
|
|
AddAssemblyReference(a);
|
|
Util.AddAssemblyToStringCollection(a, ccu.ReferencedAssemblies);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a new source file that will be added to the compilation. See the public overload
|
|
/// method for detail.
|
|
/// </devdoc>
|
|
internal virtual TextWriter CreateCodeFile(BuildProvider buildProvider, out string filename) {
|
|
|
|
string generatedFilePath = GetTempFilePhysicalPathWithAssert(_codeProvider.FileExtension);
|
|
filename = generatedFilePath;
|
|
|
|
if (buildProvider != null) {
|
|
if (_buildProviderToSourceFileMap == null)
|
|
_buildProviderToSourceFileMap = new Hashtable();
|
|
_buildProviderToSourceFileMap[buildProvider] = generatedFilePath;
|
|
buildProvider.SetContributedCode();
|
|
}
|
|
|
|
_sourceFiles.Add(generatedFilePath);
|
|
|
|
return CreateCodeFileWithAssert(generatedFilePath);
|
|
}
|
|
|
|
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
private StreamWriter CreateCodeFileWithAssert(string generatedFilePath) {
|
|
Stream temp = new FileStream(generatedFilePath, FileMode.Create, FileAccess.Write, FileShare.Read);
|
|
return new StreamWriter(temp, Encoding.UTF8);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates a new source file that will be added to the compilation. The build provider
|
|
/// can write source code to this file using the returned TextWriter.
|
|
/// The build provider should close the TextWriter when it is done writing to it.
|
|
/// The build provider should pass itself as a parameter to this method.
|
|
/// </devdoc>
|
|
public TextWriter CreateCodeFile(BuildProvider buildProvider) {
|
|
// Ignore the unused filename param.
|
|
string filename;
|
|
|
|
return CreateCodeFile(buildProvider, out filename);
|
|
}
|
|
|
|
|
|
// Indicates whether the assemblyBuilder has reached its capacity limit.
|
|
internal bool IsBatchFull {
|
|
get {
|
|
return (_sourceFiles.Count >= _maxBatchSize) ||
|
|
(_totalFileLength >= _maxBatchGeneratedFileSize);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Adds a CodeCompileUnit to the compilation. This is typically used as an
|
|
/// alternative to CreateSourceFile, by providers who are CodeDOM aware.
|
|
/// The build provider should pass itself as a parameter to this method.
|
|
/// </devdoc>
|
|
public void AddCodeCompileUnit(BuildProvider buildProvider, CodeCompileUnit compileUnit) {
|
|
|
|
// Add a checksum pragma to the compile unit if appropriate
|
|
AddChecksumPragma(buildProvider, compileUnit);
|
|
|
|
// Add all the referenced assemblies to the CodeCompileUnit in case the CodeDom
|
|
// provider needs them for code generation
|
|
Util.AddAssembliesToStringCollection(_initialReferencedAssemblies, compileUnit.ReferencedAssemblies);
|
|
|
|
// Merge the _additionalReferencedAssemblies from individul build providers
|
|
Util.AddAssembliesToStringCollection(_additionalReferencedAssemblies, compileUnit.ReferencedAssemblies);
|
|
|
|
String filename;
|
|
|
|
// Revert impersonation when generating source code in the codegen dir (VSWhidbey 176576)
|
|
using (new ProcessImpersonationContext()) {
|
|
TextWriter writer = CreateCodeFile(buildProvider, out filename);
|
|
|
|
try {
|
|
_codeProvider.GenerateCodeFromCompileUnit(compileUnit, writer, null /*CodeGeneratorOptions*/);
|
|
}
|
|
finally {
|
|
writer.Flush();
|
|
writer.Close();
|
|
}
|
|
}
|
|
|
|
if (filename != null) {
|
|
_totalFileLength += GetFileLengthWithAssert(filename);
|
|
}
|
|
}
|
|
|
|
// Assert to be able to get the length of the file in the CodeGen dir
|
|
[FileIOPermission(SecurityAction.Assert, AllFiles = FileIOPermissionAccess.Read)]
|
|
private long GetFileLengthWithAssert(string filename) {
|
|
FileInfo info = new FileInfo(filename);
|
|
return info.Length;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Tell the host about a type that is being generated. This allows the host
|
|
/// To generate a fast object factory for it.
|
|
/// </devdoc>
|
|
public void GenerateTypeFactory(string typeName) {
|
|
|
|
// Create the object factory generator on demand
|
|
if (_objectFactoryGenerator == null) {
|
|
_objectFactoryGenerator = new ObjectFactoryCodeDomTreeGenerator(OutputAssemblyName);
|
|
}
|
|
|
|
// Add a method to fast create this type
|
|
_objectFactoryGenerator.AddFactoryMethod(typeName);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a new resource that will be added to the compilation. The build provider
|
|
/// can write to it using the returned Stream.
|
|
/// The build provider should close the Stream when it is done writing to it.
|
|
/// The build provider should pass itself as a parameter to this method.
|
|
/// </devdoc>
|
|
public Stream CreateEmbeddedResource(BuildProvider buildProvider, string name) {
|
|
|
|
// Make sure it's just a valid simple file name
|
|
if (!Util.IsValidFileName(name)) {
|
|
throw new ArgumentException(null, name);
|
|
}
|
|
|
|
string resourceDir = BuildManager.CodegenResourceDir;
|
|
string resourceFile = Path.Combine(resourceDir, name);
|
|
CreateTempResourceDirectoryIfNecessary();
|
|
|
|
_tempFiles.AddFile(resourceFile, _tempFiles.KeepFiles);
|
|
|
|
if (_embeddedResourceFiles == null)
|
|
_embeddedResourceFiles = new StringSet();
|
|
|
|
_embeddedResourceFiles.Add(resourceFile);
|
|
|
|
// Assert to be able to create the file in the temp dir
|
|
InternalSecurityPermissions.FileWriteAccess(resourceDir).Assert();
|
|
|
|
return File.OpenWrite(resourceFile);
|
|
}
|
|
|
|
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
private void CreateTempResourceDirectoryIfNecessary() {
|
|
// Create the temp resource directory if needed
|
|
string resourceDir = BuildManager.CodegenResourceDir;
|
|
if (!FileUtil.DirectoryExists(resourceDir)) {
|
|
Directory.CreateDirectory(resourceDir);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns a CodeDomProvider that the build provider can use to generate a CodeCompileUnit.
|
|
/// </devdoc>
|
|
public CodeDomProvider CodeDomProvider {
|
|
get { return _codeProvider; }
|
|
}
|
|
|
|
private string _tempFilePhysicalPathPrefix;
|
|
private string TempFilePhysicalPathPrefix {
|
|
get {
|
|
if (_tempFilePhysicalPathPrefix == null) {
|
|
_tempFilePhysicalPathPrefix = Path.Combine(_tempFiles.TempDir, OutputAssemblyName) + ".";
|
|
|
|
// Append the culture name to avoid naming conflicts
|
|
if (CultureName != null) {
|
|
_tempFilePhysicalPathPrefix += CultureName + "_";
|
|
}
|
|
}
|
|
|
|
return _tempFilePhysicalPathPrefix;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns the physical path to a temporary file that the build provider
|
|
/// can use for intermediate results. Note that the file is not actually
|
|
/// created. It is up to the build provider to do this.
|
|
/// The temp file's extension is passed in by the build provider.
|
|
/// The file is automatically deleted after the compilation, so the
|
|
/// build provider does not need to explicitly delete it.
|
|
/// </devdoc>
|
|
public string GetTempFilePhysicalPath(string extension) {
|
|
|
|
// Do the right thing depending on whether the extension include the starting '.'
|
|
string tempPath;
|
|
if (!String.IsNullOrEmpty(extension) && extension[0] == '.') {
|
|
tempPath = TempFilePhysicalPathPrefix + ((_fileCount++) + extension);
|
|
}
|
|
else {
|
|
tempPath = TempFilePhysicalPathPrefix + ((_fileCount++) + "." + extension);
|
|
}
|
|
|
|
_tempFiles.AddFile(tempPath, _tempFiles.KeepFiles);
|
|
|
|
InternalSecurityPermissions.PathDiscovery(tempPath).Demand();
|
|
|
|
return tempPath;
|
|
}
|
|
|
|
// End of public contract
|
|
|
|
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
internal string GetTempFilePhysicalPathWithAssert(string extension) {
|
|
return GetTempFilePhysicalPath(extension);
|
|
}
|
|
|
|
private void AddCompileWithBuildProvider(VirtualPath virtualPath, BuildProvider owningBuildProvider) {
|
|
|
|
BuildProvider buildProvider = BuildManager.CreateBuildProvider(virtualPath,
|
|
_compConfig, _initialReferencedAssemblies, true /*failIfUnknown*/);
|
|
|
|
// Since it's referenced via compileWith, it doesn't need its own build result
|
|
buildProvider.SetNoBuildResult();
|
|
|
|
// If it's a CompileWith provider, remember the main provider
|
|
SourceFileBuildProvider sourceBuildProvider = buildProvider as SourceFileBuildProvider;
|
|
if (sourceBuildProvider != null)
|
|
sourceBuildProvider.OwningBuildProvider = owningBuildProvider;
|
|
|
|
AddBuildProvider(buildProvider);
|
|
}
|
|
|
|
internal virtual void AddBuildProvider(BuildProvider buildProvider) {
|
|
|
|
// By default, use the build provider itself as the key
|
|
object hashtableKey = buildProvider;
|
|
|
|
bool isFolderLevel = false;
|
|
|
|
// If the buildProvider is a folderLevel build provider, use the build provider itself
|
|
// so that multiple build providers can work on the same path.
|
|
if (_compConfig.FolderLevelBuildProviders != null) {
|
|
Type t = buildProvider.GetType();
|
|
isFolderLevel = _compConfig.FolderLevelBuildProviders.IsFolderLevelBuildProvider(t);
|
|
}
|
|
|
|
// Keep track of the build provider's virtual path, if any
|
|
if (buildProvider.VirtualPath != null && !isFolderLevel) {
|
|
|
|
// It has a virtual path, so use that as the key
|
|
hashtableKey = buildProvider.VirtualPath;
|
|
|
|
// If we already had it, ignore it. This can happen when there is a user control
|
|
// with a code beside in App_Code (VSWhidbey 481426)
|
|
if (_buildProviders.ContainsKey(hashtableKey))
|
|
return;
|
|
}
|
|
|
|
_buildProviders[hashtableKey] = buildProvider;
|
|
|
|
// Ask the provider to generate the code
|
|
// If it throws an Xml exception, extra the relevant info and turn it
|
|
// into our own ParseException
|
|
try {
|
|
buildProvider.GenerateCode(this);
|
|
}
|
|
catch (XmlException e) {
|
|
throw new HttpParseException(e.Message, null /*innerException*/,
|
|
buildProvider.VirtualPath, null /*sourceCode*/, e.LineNumber);
|
|
}
|
|
catch (XmlSchemaException e) {
|
|
throw new HttpParseException(e.Message, null /*innerException*/,
|
|
buildProvider.VirtualPath, null /*sourceCode*/, e.LineNumber);
|
|
}
|
|
catch (Exception e) {
|
|
throw new HttpParseException(e.Message, e,
|
|
buildProvider.VirtualPath, null /*sourceCode*/, 1);
|
|
}
|
|
|
|
// Handle any 'compileWith' dependencies, i.e. files that must be compiled
|
|
// within the same assembly as the current file
|
|
InternalBuildProvider internalBuildProvider = buildProvider as InternalBuildProvider;
|
|
if (internalBuildProvider != null) {
|
|
ICollection compileWith = internalBuildProvider.GetCompileWithDependencies();
|
|
if (compileWith != null) {
|
|
foreach (VirtualPath virtualPath in compileWith) {
|
|
|
|
// If we already have it, ignore it
|
|
if (_buildProviders.ContainsKey(virtualPath.VirtualPathString))
|
|
continue;
|
|
|
|
// Add the compileWith dependency to our compilation
|
|
AddCompileWithBuildProvider(virtualPath, internalBuildProvider);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void AddAssemblyCultureAttribute() {
|
|
|
|
if (CultureName == null) return;
|
|
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(System.Reflection.AssemblyCultureAttribute)),
|
|
new CodeAttributeArgument[] {
|
|
new CodeAttributeArgument(new CodePrimitiveExpression(CultureName))});
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
|
|
|
|
private void AddAspNetGeneratedCodeAttribute() {
|
|
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(GeneratedCodeAttribute)));
|
|
declaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("ASP.NET")));
|
|
declaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(VersionInfo.SystemWebVersion)));
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
|
|
private void AddAllowPartiallyTrustedCallersAttribute() {
|
|
if (BuildManager.CompileWithAllowPartiallyTrustedCallersAttribute) {
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(AllowPartiallyTrustedCallersAttribute)));
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
}
|
|
|
|
private void AddAssemblyKeyFileAttribute() {
|
|
if (!String.IsNullOrEmpty(BuildManager.StrongNameKeyFile)) {
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(AssemblyKeyFileAttribute)),
|
|
new CodeAttributeArgument(new CodePrimitiveExpression(BuildManager.StrongNameKeyFile)));
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
}
|
|
|
|
private void AddAssemblyKeyContainerAttribute() {
|
|
if (!String.IsNullOrEmpty(BuildManager.StrongNameKeyContainer)) {
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(AssemblyKeyNameAttribute)),
|
|
new CodeAttributeArgument(new CodePrimitiveExpression(BuildManager.StrongNameKeyContainer)));
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
}
|
|
|
|
private void AddAssemblyDelaySignAttribute() {
|
|
if (BuildManager.CompileWithDelaySignAttribute) {
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(AssemblyDelaySignAttribute)),
|
|
new CodeAttributeArgument(new CodePrimitiveExpression(true)));
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
}
|
|
|
|
private void AddSecurityRulesAttribute() {
|
|
// Skip applying the attribute if targeting 2.0/3.5, since the attribute
|
|
// is only available in 4.0 and above.
|
|
if (MultiTargetingUtil.IsTargetFramework20 || MultiTargetingUtil.IsTargetFramework35) {
|
|
return;
|
|
}
|
|
|
|
TrustSection trustSection = RuntimeConfig.GetAppConfig().Trust;
|
|
CodeAttributeDeclaration declaration;
|
|
Type attrType = typeof(SecurityRulesAttribute);
|
|
Type enumType = typeof(SecurityRuleSet);
|
|
if (trustSection.LegacyCasModel) {
|
|
SecurityRuleSet set = SecurityRuleSet.Level1;
|
|
string fieldName = Enum.GetName(enumType, set);
|
|
CodeFieldReferenceExpression field = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(enumType), fieldName);
|
|
declaration = new CodeAttributeDeclaration(new CodeTypeReference(attrType), new CodeAttributeArgument(field));
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
else {
|
|
SecurityRuleSet set = SecurityRuleSet.Level2;
|
|
string fieldName = Enum.GetName(enumType, set);
|
|
CodeFieldReferenceExpression field = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(enumType), fieldName);
|
|
declaration = new CodeAttributeDeclaration(new CodeTypeReference(attrType), new CodeAttributeArgument(field));
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
}
|
|
|
|
private void AddTargetFrameworkAttribute() {
|
|
if (MultiTargetingUtil.TargetFrameworkVersion.Major >= 4) {
|
|
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(
|
|
new CodeTypeReference(typeof(System.Runtime.Versioning.TargetFrameworkAttribute)),
|
|
new CodeAttributeArgument(new CodePrimitiveExpression(BuildManager.TargetFramework.FullName)));
|
|
|
|
AddAssemblyAttribute(declaration);
|
|
}
|
|
}
|
|
|
|
// Add an assembly level attribute to the assembly
|
|
private void AddAssemblyAttribute(CodeAttributeDeclaration declaration) {
|
|
|
|
if (_miscCodeCompileUnit == null)
|
|
_miscCodeCompileUnit = new CodeCompileUnit();
|
|
|
|
_miscCodeCompileUnit.AssemblyCustomAttributes.Add(declaration);
|
|
}
|
|
|
|
private void GenerateMiscCodeCompileUnit() {
|
|
|
|
// If there aren't any, return
|
|
if (_miscCodeCompileUnit == null)
|
|
return;
|
|
|
|
AddCodeCompileUnit(null /*buildProvider*/, _miscCodeCompileUnit);
|
|
}
|
|
|
|
// Add a checksum pragma. This is used for improved debugging experience.
|
|
private void AddChecksumPragma(BuildProvider buildProvider, CodeCompileUnit compileUnit) {
|
|
|
|
// If we can't get a virtual path, do nothing
|
|
if (buildProvider == null || buildProvider.VirtualPath == null)
|
|
return;
|
|
|
|
// Only do this if we're compiling in debug mode
|
|
if (!_compilerType.CompilerParameters.IncludeDebugInformation)
|
|
return;
|
|
|
|
string physicalPath = HostingEnvironment.MapPathInternal(buildProvider.VirtualPath);
|
|
|
|
// Only do this is the file physically exists, which it would not in the
|
|
// case of a non-file based VirtualPathProvider. In such case, there is
|
|
// no point in putting the pragma, since the debugger could not locate
|
|
// the file anyway.
|
|
if (!File.Exists(physicalPath))
|
|
return;
|
|
|
|
CodeChecksumPragma pragma = new CodeChecksumPragma() {
|
|
ChecksumAlgorithmId = s_codeChecksumSha1Id
|
|
};
|
|
|
|
if (_compConfig.UrlLinePragmas) {
|
|
pragma.FileName = ErrorFormatter.MakeHttpLinePragma(buildProvider.VirtualPathObject.VirtualPathString);
|
|
}
|
|
else {
|
|
pragma.FileName = physicalPath;
|
|
}
|
|
|
|
// Generate a SHA1 hash from the contents of the file
|
|
|
|
// The VS debugger uses a cryptographic hash of the file being debugged so that it doesn't accidentally
|
|
// display to the user the wrong version of the file. This is merely a convenience feature for debugging
|
|
// purposes and is not security-related in any way. Since VS only supports MD5 and SHA1 hashes, we just
|
|
// use SHA1 and suppress the [Obsolete] warning.
|
|
#pragma warning disable 618
|
|
using (Stream stream = new FileStream(physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read)) {
|
|
using (SHA1 hashAlgorithm = CryptoAlgorithms.CreateSHA1()) {
|
|
pragma.ChecksumData = hashAlgorithm.ComputeHash(stream);
|
|
}
|
|
}
|
|
#pragma warning restore 618
|
|
|
|
// Add the pragma to the CodeCompileUnit
|
|
compileUnit.StartDirectives.Add(pragma);
|
|
}
|
|
|
|
internal CompilerParameters GetCompilerParameters() {
|
|
CompilerParameters compilParams = _compilerType.CompilerParameters;
|
|
|
|
string dir = _tempFiles.TempDir;
|
|
|
|
// If a culture is set, modify the assembly name and location based on it
|
|
if (CultureName != null) {
|
|
dir = Path.Combine(dir, CultureName);
|
|
Directory.CreateDirectory(dir);
|
|
compilParams.OutputAssembly = Path.Combine(dir, OutputAssemblyName + ".resources.dll");
|
|
}
|
|
else {
|
|
compilParams.OutputAssembly = Path.Combine(dir, OutputAssemblyName + ".dll");
|
|
}
|
|
|
|
// If such file already exist, try to delete or rename it
|
|
if (File.Exists(compilParams.OutputAssembly))
|
|
Util.RemoveOrRenameFile(compilParams.OutputAssembly);
|
|
|
|
compilParams.TempFiles = _tempFiles;
|
|
|
|
// Create the string resource file (shared by all the pages we're compiling)
|
|
if (_stringResourceBuilder != null && _stringResourceBuilder.HasStrings) {
|
|
string resFileName = _tempFiles.AddExtension("res");
|
|
_stringResourceBuilder.CreateResourceFile(resFileName);
|
|
compilParams.Win32Resource = resFileName;
|
|
}
|
|
|
|
// Add all the embedded resources to the compilParams
|
|
if (_embeddedResourceFiles != null) {
|
|
foreach (string aname in _embeddedResourceFiles)
|
|
compilParams.EmbeddedResources.Add(aname);
|
|
}
|
|
|
|
// Merge the two sets of assemblies
|
|
if (_additionalReferencedAssemblies != null) {
|
|
foreach (Assembly assembly in _additionalReferencedAssemblies) {
|
|
_initialReferencedAssemblies.Add(assembly);
|
|
}
|
|
}
|
|
|
|
// Add all the referenced assemblies to the compilParams
|
|
Util.AddAssembliesToStringCollection(_initialReferencedAssemblies, compilParams.ReferencedAssemblies);
|
|
|
|
// Make any fix up adjustments to the CompilerParameters to work around some issues
|
|
FixUpCompilerParameters(_compConfig, _compilerType.CodeDomProviderType, compilParams);
|
|
|
|
return compilParams;
|
|
}
|
|
|
|
static string s_vbImportsString;
|
|
|
|
private static void AddVBGlobalNamespaceImports(CompilerParameters compilParams) {
|
|
// Put together the VB import string on demand
|
|
if (s_vbImportsString == null) {
|
|
PagesSection pagesConfig = MTConfigUtil.GetPagesAppConfig();
|
|
if (pagesConfig.Namespaces == null) {
|
|
s_vbImportsString = String.Empty;
|
|
}
|
|
else {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("/imports:");
|
|
|
|
bool nextItemNeedsComma = false;
|
|
|
|
// Auto-import Microsoft.VisualBasic is needed
|
|
if (pagesConfig.Namespaces.AutoImportVBNamespace) {
|
|
sb.Append("Microsoft.VisualBasic");
|
|
nextItemNeedsComma = true;
|
|
}
|
|
|
|
// Add all the namespaces from the config <namespaces> section
|
|
foreach (NamespaceInfo entry in pagesConfig.Namespaces) {
|
|
|
|
// If there was a previous entry, we need a comma separator
|
|
if (nextItemNeedsComma)
|
|
sb.Append(',');
|
|
|
|
sb.Append(entry.Namespace);
|
|
|
|
nextItemNeedsComma = true;
|
|
}
|
|
|
|
s_vbImportsString = sb.ToString();
|
|
}
|
|
}
|
|
|
|
// Prepend it to the compilerOptions
|
|
if (s_vbImportsString.Length > 0) {
|
|
if (compilParams.CompilerOptions == null)
|
|
compilParams.CompilerOptions = s_vbImportsString;
|
|
else
|
|
compilParams.CompilerOptions = s_vbImportsString + " " + compilParams.CompilerOptions;
|
|
}
|
|
}
|
|
|
|
// Command line string for My.* support
|
|
private const string MySupport = @"/define:_MYTYPE=\""Web\""";
|
|
|
|
private static void AddVBMyFlags(CompilerParameters compilParams) {
|
|
|
|
// Prepend it to the compilerOptions
|
|
if (compilParams.CompilerOptions == null)
|
|
compilParams.CompilerOptions = MySupport;
|
|
else
|
|
compilParams.CompilerOptions = MySupport + " " + compilParams.CompilerOptions;
|
|
}
|
|
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "Warnings was about use of CompilerParameters.CoreAssemblyFileName which was not set by user supplied string - so okay.")]
|
|
internal static void FixUpCompilerParameters(CompilationSection compilationSection, Type codeDomProviderType, CompilerParameters compilParams) {
|
|
// The mscorlib reference is special cased, and needs to be passed via the CoreAssemblyFileName property.
|
|
if (BuildManagerHost.InClientBuildManager && !MultiTargetingUtil.IsTargetFramework20 && !MultiTargetingUtil.IsTargetFramework35) {
|
|
string coreAssemblyFile;
|
|
AssemblyResolver.GetPathToReferenceAssembly(typeof(string).Assembly, out coreAssemblyFile);
|
|
compilParams.CoreAssemblyFileName = coreAssemblyFile;
|
|
}
|
|
|
|
// DevDiv 404267: If the developer enabled 'warnings as errors', we should disable [Obsolete] warnings. This helps
|
|
// prevent in-place framework updates from breaking runtime compilation of pages. We only respect this attribute
|
|
// when not in the CBM, as CBM is a design-time feature instead of a runtime feature, and the developer probably
|
|
// wants to be notified of all errors at design time.
|
|
bool disableObsoleteWarnings = !BuildManagerHost.InClientBuildManager && compilationSection.DisableObsoleteWarnings;
|
|
|
|
// If C#, remove the warning that complains about variables that start with "__"
|
|
// Also ignore warning that complains about assemblyKeyName and delaysign
|
|
// Also ignore warning about assuming assembly versions matching (CS1701, DevDiv 137847, warning about System.Web.Extensions v1.0 matching v3.5)
|
|
if (codeDomProviderType == typeof(Microsoft.CSharp.CSharpCodeProvider)) {
|
|
List<string> noWarnStrings = new List<string>(5);
|
|
noWarnStrings.AddRange(new string[] { "1659", "1699", "1701" });
|
|
|
|
if (disableObsoleteWarnings) {
|
|
noWarnStrings.Add("612"); // [Obsolete] without message
|
|
noWarnStrings.Add("618"); // [Obsolete("with message")]
|
|
}
|
|
|
|
CodeDomUtility.PrependCompilerOption(compilParams, "/nowarn:" + String.Join(";", noWarnStrings));
|
|
}
|
|
else if (codeDomProviderType == typeof(Microsoft.VisualBasic.VBCodeProvider)) {
|
|
List<string> noWarnStrings = new List<string>(3);
|
|
|
|
// If VB, add all the imported namespaces on the command line (DevDiv 21499).
|
|
// This is VB only because other languages don't support global command line
|
|
// namespace imports.
|
|
AddVBGlobalNamespaceImports(compilParams);
|
|
|
|
// Add any command line flags needed to support the My.* feature
|
|
AddVBMyFlags(compilParams);
|
|
|
|
// Ignore vb warning that complains about assemblyKeyName (Dev10 662544)
|
|
// but only for target 3.5 and above (715329)
|
|
if (MultiTargetingUtil.TargetFrameworkVersion >= MultiTargetingUtil.Version35) {
|
|
noWarnStrings.Add("41008");
|
|
}
|
|
|
|
if (disableObsoleteWarnings) {
|
|
noWarnStrings.Add("40000"); // [Obsolete("with message")]
|
|
noWarnStrings.Add("40008"); // [Obsolete] without message
|
|
}
|
|
|
|
if (noWarnStrings.Count > 0) {
|
|
CodeDomUtility.PrependCompilerOption(compilParams, "/nowarn:" + String.Join(",", noWarnStrings));
|
|
}
|
|
}
|
|
|
|
ProcessProviderOptions(codeDomProviderType, compilParams);
|
|
FixTreatWarningsAsErrors(codeDomProviderType, compilParams);
|
|
|
|
// Add CodeAnalysis symbol if required by client.
|
|
if (BuildManager.PrecompilingWithCodeAnalysisSymbol) {
|
|
CodeDomUtility.PrependCompilerOption(compilParams, "/define:CODE_ANALYSIS");
|
|
}
|
|
}
|
|
|
|
// DevDiv 114316
|
|
// CodeDom sets TreatWarningAsErrors to true whenever warningLevel is non-zero.
|
|
// To get warnings only, the workaround is to use /warnaserror- in CompilerOptions.
|
|
// However this does not work in some cases, as TreatWarningAsErrors set to true still emits
|
|
// /warnaserror+.
|
|
// So, whenever the user wants /warnaserror[+|-|numberlist], we explicitly set TreatWarningsAsErrors to false,
|
|
// so that the /warnaserror+ is not emitted, and the user can specify exactly what is desired.
|
|
internal static void FixTreatWarningsAsErrors(Type codeDomProviderType, CompilerParameters compilParams) {
|
|
// Only do so for C# and VB.
|
|
if (codeDomProviderType != typeof(Microsoft.CSharp.CSharpCodeProvider) &&
|
|
codeDomProviderType != typeof(Microsoft.VisualBasic.VBCodeProvider))
|
|
return;
|
|
|
|
if (CultureInfo.InvariantCulture.CompareInfo.IndexOf(compilParams.CompilerOptions, "/warnaserror", CompareOptions.IgnoreCase) >= 0)
|
|
compilParams.TreatWarningsAsErrors = false;
|
|
}
|
|
|
|
|
|
// Check for OptionInfer and WarnAsError. This is the workaround as use of compilerOptions is not allowed in partial trust.
|
|
// Devdiv 130325
|
|
//
|
|
private static void ProcessProviderOptions(Type codeDomProviderType, CompilerParameters compilParams) {
|
|
IDictionary<string, string> providerOptions = CompilationUtil.GetProviderOptions(codeDomProviderType);
|
|
if (providerOptions == null) return;
|
|
|
|
// For C# and VB, check for WarnAsError
|
|
if (codeDomProviderType == typeof(Microsoft.VisualBasic.VBCodeProvider) ||
|
|
codeDomProviderType == typeof(Microsoft.CSharp.CSharpCodeProvider))
|
|
ProcessBooleanProviderOption("WarnAsError", "/warnaserror+", "/warnaserror-", providerOptions, compilParams);
|
|
|
|
// Only process OptionInfer for v3.5 compiler (or above)
|
|
if (codeDomProviderType == null || !CompilationUtil.IsCompilerVersion35OrAbove(codeDomProviderType))
|
|
return;
|
|
|
|
// For VB, check for OptionInfer
|
|
if (codeDomProviderType == typeof(Microsoft.VisualBasic.VBCodeProvider))
|
|
ProcessBooleanProviderOption("OptionInfer", "/optionInfer+", "/optionInfer-", providerOptions, compilParams);
|
|
|
|
}
|
|
|
|
private static void ProcessBooleanProviderOption(string providerOptionName, string trueCompilerOption, string falseCompilerOption,
|
|
IDictionary<string, string> providerOptions, CompilerParameters compilParams) {
|
|
|
|
if (providerOptions == null || compilParams == null) return;
|
|
Debug.Assert(providerOptionName != null, "providerOptionName should not be null");
|
|
Debug.Assert(trueCompilerOption != null, "trueCompilerOption should not be null");
|
|
Debug.Assert(falseCompilerOption != null, "falseCompilerOption should not be null");
|
|
|
|
string providerOptionValue = null;
|
|
if (!providerOptions.TryGetValue(providerOptionName, out providerOptionValue)) return;
|
|
if (string.IsNullOrEmpty(providerOptionValue))
|
|
throw new System.Configuration.ConfigurationErrorsException(SR.GetString(SR.Property_NullOrEmpty, CompilationUtil.CodeDomProviderOptionPath + providerOptionName));
|
|
|
|
bool value;
|
|
|
|
if (Boolean.TryParse(providerOptionValue, out value)) {
|
|
// If the value is boolean, insert the compiler options
|
|
if (value)
|
|
CodeDomUtility.AppendCompilerOption(compilParams, trueCompilerOption);
|
|
else
|
|
CodeDomUtility.AppendCompilerOption(compilParams, falseCompilerOption);
|
|
}
|
|
else {
|
|
// If the value is not boolean, throw an exception
|
|
throw new System.Configuration.ConfigurationErrorsException(SR.GetString(SR.Value_must_be_boolean, CompilationUtil.CodeDomProviderOptionPath + providerOptionName));
|
|
}
|
|
}
|
|
|
|
|
|
internal CompilerResults Compile() {
|
|
|
|
// First, check if there is something to compile
|
|
if (_sourceFiles.Count == 0 && _embeddedResourceFiles == null)
|
|
return null;
|
|
|
|
// if we have some fast object factories to generate, get the CodeCompileUnit
|
|
if (_objectFactoryGenerator != null) {
|
|
_miscCodeCompileUnit = _objectFactoryGenerator.CodeCompileUnit;
|
|
}
|
|
|
|
// Add a culture attribute if needed
|
|
AddAssemblyCultureAttribute();
|
|
|
|
// Add a ComVisible(false) attribute (VSWhidbey 436453)
|
|
// Actually, don't do it to avoid breaking migrated apps (VSWhidbey 446788)
|
|
//AddComVisibleAttribute();
|
|
|
|
// Add an AspNetGeneratedCode attribute to help fxcop ignore some violations (VSWhidbey 437581)
|
|
AddAspNetGeneratedCodeAttribute();
|
|
|
|
// Add an AllowPartiallyTrustedCallers attribute to make strong-name assemblies. (Devdiv 39696)
|
|
AddAllowPartiallyTrustedCallersAttribute();
|
|
|
|
AddAssemblyDelaySignAttribute();
|
|
|
|
AddAssemblyKeyFileAttribute();
|
|
|
|
AddAssemblyKeyContainerAttribute();
|
|
|
|
AddSecurityRulesAttribute();
|
|
|
|
AddTargetFrameworkAttribute();
|
|
|
|
// Generate a source file for the misc top level items if needed
|
|
GenerateMiscCodeCompileUnit();
|
|
|
|
CompilerParameters compilParams = GetCompilerParameters();
|
|
|
|
string[] files = new string[_sourceFiles.Count];
|
|
_sourceFiles.CopyTo(files, 0);
|
|
|
|
// Increment compilation counter
|
|
PerfCounters.IncrementCounter(AppPerfCounter.COMPILATIONS);
|
|
|
|
// Raise Web Event
|
|
WebBaseEvent.RaiseSystemEvent(this, WebEventCodes.ApplicationCompilationStart);
|
|
|
|
HttpContext context = HttpContext.Current;
|
|
|
|
if (context != null) {
|
|
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_COMPILE_ENTER, context.WorkerRequest);
|
|
}
|
|
|
|
CompilerResults results = null;
|
|
|
|
try {
|
|
try {
|
|
// Revert impersonation when compiling source code in the codegen dir (VSWhidbey 176576)
|
|
using (new ProcessImpersonationContext()) {
|
|
results = _codeProvider.CompileAssemblyFromFile(compilParams, files);
|
|
}
|
|
}
|
|
finally {
|
|
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure) && context != null) {
|
|
|
|
string fileNames = null;
|
|
if (_buildProviders.Count < 20) {
|
|
IDictionaryEnumerator e = _buildProviders.GetEnumerator();
|
|
while(e.MoveNext()) {
|
|
if (fileNames != null)
|
|
fileNames += ",";
|
|
fileNames += e.Key;
|
|
}
|
|
}
|
|
else {
|
|
fileNames = String.Format(CultureInfo.InstalledUICulture, SR.Resources.GetString(SR.Etw_Batch_Compilation, CultureInfo.InstalledUICulture), new object[1] {_buildProviders.Count});
|
|
}
|
|
|
|
string status;
|
|
if (results != null && (results.NativeCompilerReturnValue != 0 || results.Errors.HasErrors))
|
|
status = SR.Resources.GetString(SR.Etw_Failure, CultureInfo.InstalledUICulture);
|
|
else
|
|
status = SR.Resources.GetString(SR.Etw_Success, CultureInfo.InstalledUICulture);
|
|
|
|
EtwTrace.Trace(EtwTraceType.ETW_TYPE_COMPILE_LEAVE, context.WorkerRequest, fileNames, status);
|
|
}
|
|
}
|
|
}
|
|
catch { throw; } // Prevent Exception Filter Security Issue (ASURT 122835)
|
|
|
|
// If an IAssemblyPostProcessor is registered, call it
|
|
Type postProcessorType = _compConfig.AssemblyPostProcessorTypeInternal;
|
|
if (postProcessorType != null) {
|
|
using (IAssemblyPostProcessor postProcessor = (IAssemblyPostProcessor) HttpRuntime.FastCreatePublicInstance(postProcessorType)) {
|
|
postProcessor.PostProcessAssembly(results.PathToAssembly);
|
|
}
|
|
}
|
|
|
|
// Raise Web Event
|
|
WebBaseEvent.RaiseSystemEvent(this, WebEventCodes.ApplicationCompilationEnd);
|
|
|
|
if (results != null) {
|
|
|
|
// Invalidate an invalid assembly to trigger recompilation
|
|
InvalidateInvalidAssembly(results, compilParams);
|
|
|
|
// Fix up with line pragmas to account for the http case, and for some special conditions
|
|
FixUpLinePragmas(results);
|
|
|
|
if (results.Errors.HasErrors) {
|
|
// Give all the BuildProviders a chance to look at the compile errors, and possibly tweak them
|
|
foreach (BuildProvider buildProvider in BuildProviders) {
|
|
buildProvider.ProcessCompileErrors(results);
|
|
}
|
|
}
|
|
|
|
// If there is a CBM callback, inform it of the errors/warnings
|
|
if (BuildManager.CBMCallback != null) {
|
|
foreach (CompilerError error in results.Errors) {
|
|
BuildManager.CBMCallback.ReportCompilerError(error);
|
|
}
|
|
}
|
|
|
|
// If there are errors, increment the relevant perf counters and throw
|
|
if (results.NativeCompilerReturnValue != 0 || results.Errors.HasErrors) {
|
|
|
|
// Increment the compilation error and total error counters
|
|
PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_COMPILING);
|
|
PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);
|
|
|
|
throw new HttpCompileException(results, GetErrorSourceFileContents(results));
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
private void InvalidateInvalidAssembly(CompilerResults results, CompilerParameters compilParams) {
|
|
// VSWhidbey 610291
|
|
// If target assembly gets locked, we invalidate the assembly, so that it does
|
|
// not get used, and the next compilation will use a new assembly name.
|
|
// CS0016 is the error code for "Could not write to output file 'file' -- 'reason'"
|
|
|
|
if (results == null || !results.Errors.HasErrors)
|
|
return;
|
|
|
|
foreach (CompilerError error in results.Errors) {
|
|
if (error.IsWarning) continue;
|
|
|
|
if (StringUtil.EqualsIgnoreCase(error.ErrorNumber, "CS0016")){
|
|
|
|
// Also invalidate the base assembly if this is a localized resource assembly
|
|
if (CultureName != null) {
|
|
string dir = _tempFiles.TempDir;
|
|
string baseAssemblyFile = Path.Combine(dir, OutputAssemblyName + ".dll");
|
|
DiskBuildResultCache.TryDeleteFile(new FileInfo(baseAssemblyFile));
|
|
}
|
|
|
|
// Invalidate the target assembly
|
|
DiskBuildResultCache.TryDeleteFile(compilParams.OutputAssembly);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Fix up all the source files in the errors in case they are HTTP (VS compiler scenario).
|
|
* Also, fix the error in case the base class was incorrect in the code beside model
|
|
*/
|
|
private void FixUpLinePragmas(CompilerResults results) {
|
|
|
|
CompilerError badBaseClassError = null;
|
|
|
|
// Go through the errors backwards so we can delete them as needed
|
|
for (int i=results.Errors.Count-1; i>=0; i--) {
|
|
CompilerError error = results.Errors[i];
|
|
|
|
string physicalPath = ErrorFormatter.ResolveHttpFileName(error.FileName);
|
|
|
|
// Only replace it by the physical path if it actually exists, which may not
|
|
// be the case when using a VirtualPathProvider
|
|
if (File.Exists(physicalPath)) {
|
|
error.FileName = physicalPath;
|
|
|
|
// If it is our special marker line number, remember it and remove it.
|
|
// We place the marker at two places: 1) before setting AppRelativeVirtualPath in the constructor,
|
|
// and 2) before the method FrameworkInitialize.
|
|
// For the generated method FrameworkInitialize, the method comes one line after
|
|
// the marker, due to an additional line taken by the DebuggerNonUserCodeAttribute. (DevDiv 175681)
|
|
if (error.Line == TemplateControlCodeDomTreeGenerator.badBaseClassLineMarker ||
|
|
(error.Line == TemplateControlCodeDomTreeGenerator.badBaseClassLineMarker + 1 &&
|
|
error.ErrorText != null && error.ErrorText.IndexOf("FrameworkInitialize", StringComparison.OrdinalIgnoreCase) >= 0)) {
|
|
badBaseClassError = error;
|
|
results.Errors.RemoveAt(i);
|
|
}
|
|
else if (error.Line > TemplateControlCodeDomTreeGenerator.badBaseClassLineMarker &&
|
|
error.Line < TemplateControlCodeDomTreeGenerator.badBaseClassLineMarker + 50) {
|
|
|
|
// Also, if within range of it, remove it altogether
|
|
results.Errors.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we found our special marker error, we're most likely in a situation where
|
|
// the class in the code beside file doesn't match the 'inherits' in the aspx/ascx,
|
|
// or is missing the based type (or has the wrong base type). In that case, change
|
|
// the error message to make the problem explicit to the user (VSWhidbey 376977/468830)
|
|
if (badBaseClassError != null) {
|
|
|
|
// Read the content of the code beside file
|
|
string codeFileContent = Util.StringFromFile(badBaseClassError.FileName);
|
|
|
|
// Search for the partial class declaration within the file. We do this by searching for
|
|
// the string "partial class" in case insensitive way. This is far from fool proof, but
|
|
// it covers the common VB and C# cases, and the fallback when not found is reasonable.
|
|
int classOffset = CultureInfo.InvariantCulture.CompareInfo.IndexOf(codeFileContent,
|
|
"partial class", CompareOptions.IgnoreCase);
|
|
|
|
if (classOffset >= 0) {
|
|
// We found it, so figure out the line number from it
|
|
badBaseClassError.Line = Util.LineCount(codeFileContent, 0, classOffset) + 1;
|
|
}
|
|
else {
|
|
// Otherwise, just use 1. It won't point to the right line, but at least the error
|
|
// message is helpful
|
|
badBaseClassError.Line = 1;
|
|
}
|
|
|
|
// Change the error message to make the situation clear to the user
|
|
badBaseClassError.ErrorText = SR.GetString(SR.Bad_Base_Class_In_Code_File);
|
|
badBaseClassError.ErrorNumber = "ASPNET";
|
|
|
|
// Insert the error at the begining of the collection, since we display the first error.
|
|
results.Errors.Insert(0, badBaseClassError);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Attempt to find the generated source file that has the error, and return
|
|
* its contents as a string (for error reproting purposes).
|
|
* Note that when debug is false, we set tempFiles.KeepFiles to false, and
|
|
* all the sources will be gone by the time we get here. I filed VSWhidbey 103673,
|
|
* to get a solution to this from BCL.
|
|
*/
|
|
private string GetErrorSourceFileContents(CompilerResults results) {
|
|
|
|
if (!results.Errors.HasErrors)
|
|
return null;
|
|
|
|
// Get the physical path of the file that has the error. Note that this could be
|
|
// either the path to a high level file (e.g. aspx) if pragmas are in play,
|
|
// or the path to a generated file if there are no pragmas
|
|
string linePragma = results.Errors[0].FileName;
|
|
|
|
// Attempt to locate the correct build provider
|
|
BuildProvider buildProvider = GetBuildProviderFromLinePragma(linePragma);
|
|
|
|
if (buildProvider != null) {
|
|
// Return the generated file for this build provider
|
|
return GetGeneratedSourceFromBuildProvider(buildProvider);
|
|
}
|
|
|
|
// If we didn't find it, then we're probably in the no pragma case, in
|
|
// which case linePragma itself is the generated file
|
|
return Util.StringFromFileIfExists(linePragma);
|
|
}
|
|
|
|
internal string GetGeneratedSourceFromBuildProvider(BuildProvider buildProvider) {
|
|
|
|
// Return the generated file content for this build provider
|
|
string generatedFilePath = (string) _buildProviderToSourceFileMap[buildProvider];
|
|
return Util.StringFromFileIfExists(generatedFilePath);
|
|
}
|
|
|
|
internal BuildProvider GetBuildProviderFromLinePragma(string linePragma) {
|
|
BuildProvider buildProvider = GetBuildProviderFromLinePragmaInternal(linePragma);
|
|
|
|
// If it's a CompileWith provider, return the main provider instead
|
|
SourceFileBuildProvider sourceBuildProvider = buildProvider as SourceFileBuildProvider;
|
|
if (sourceBuildProvider != null)
|
|
buildProvider = sourceBuildProvider.OwningBuildProvider;
|
|
|
|
return buildProvider;
|
|
}
|
|
|
|
private BuildProvider GetBuildProviderFromLinePragmaInternal(string linePragma) {
|
|
|
|
// If we didn't keep track of any generated files, we can't do much
|
|
if (_buildProviderToSourceFileMap == null)
|
|
return null;
|
|
|
|
// Check if it's an http line pragma, from which we can get a VirtualPath
|
|
string virtualPath = ErrorFormatter.GetVirtualPathFromHttpLinePragma(linePragma);
|
|
|
|
// First, look for the pragma case
|
|
foreach (BuildProvider buildProvider in BuildProviders) {
|
|
|
|
// If the build provider can't give us a virtual path, skip it
|
|
if (buildProvider.VirtualPath == null)
|
|
continue;
|
|
|
|
// If we got a virtual path, use it to locate the correct BuildProvider
|
|
if (virtualPath != null) {
|
|
if (StringUtil.EqualsIgnoreCase(virtualPath, buildProvider.VirtualPath)) {
|
|
return buildProvider;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, work with the physical path
|
|
|
|
string physicalPath = HostingEnvironment.MapPathInternal(buildProvider.VirtualPath);
|
|
|
|
if (StringUtil.EqualsIgnoreCase(linePragma, physicalPath)) {
|
|
return buildProvider;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This class is used intead of AssemblyBuilder when handling
|
|
* ClientBuildManager.GetCodeDirectoryInformation
|
|
* It is instantiated via CompilerType.CreateAssemblyBuilder.
|
|
*/
|
|
internal class CbmCodeGeneratorBuildProviderHost: AssemblyBuilder {
|
|
|
|
private string _generatedFilesDir;
|
|
|
|
internal CbmCodeGeneratorBuildProviderHost(CompilationSection compConfig,
|
|
ICollection referencedAssemblies, CompilerType compilerType,
|
|
string generatedFilesDir, string outputAssemblyName)
|
|
: base(compConfig, referencedAssemblies, compilerType, outputAssemblyName) {
|
|
|
|
// Wipe out any existing directory, and recreate it
|
|
// This is where we will put generated source files
|
|
if (Directory.Exists(generatedFilesDir)) {
|
|
|
|
// Delete all the files in the directory
|
|
foreach (FileData fileData in FileEnumerator.Create(generatedFilesDir)) {
|
|
|
|
// It should only contain files
|
|
Debug.Assert(!fileData.IsDirectory);
|
|
if (fileData.IsDirectory) continue;
|
|
|
|
Debug.Trace("CbmCodeGeneratorBuildProviderHost", "Deleting " + fileData.FullName);
|
|
File.Delete(fileData.FullName);
|
|
}
|
|
|
|
}
|
|
|
|
// Create it to make sure it exists
|
|
Directory.CreateDirectory(generatedFilesDir);
|
|
|
|
_generatedFilesDir = generatedFilesDir;
|
|
}
|
|
|
|
internal override TextWriter CreateCodeFile(BuildProvider buildProvider, out string filename) {
|
|
|
|
// use GetCacheKeyFromVirtualPath to get a file name that looks like
|
|
// the original file, but is guaranteed unique across different virtual dirs.
|
|
string generatedCodeFile = BuildManager.GetCacheKeyFromVirtualPath(
|
|
buildProvider.VirtualPathObject);
|
|
|
|
generatedCodeFile = Path.Combine(_generatedFilesDir, generatedCodeFile);
|
|
generatedCodeFile = FileUtil.TruncatePathIfNeeded(generatedCodeFile, 10 /*length of extension */);
|
|
|
|
generatedCodeFile = generatedCodeFile + "." + _codeProvider.FileExtension;
|
|
filename = generatedCodeFile;
|
|
|
|
BuildManager.GenerateFileTable[buildProvider.VirtualPathObject.VirtualPathStringNoTrailingSlash] = generatedCodeFile;
|
|
|
|
Debug.Trace("CbmCodeGeneratorBuildProviderHost", "Generating " + generatedCodeFile);
|
|
|
|
Stream temp = new FileStream(generatedCodeFile, FileMode.Create, FileAccess.Write, FileShare.Read);
|
|
return new StreamWriter(temp, Encoding.UTF8);
|
|
}
|
|
|
|
internal override void AddBuildProvider(BuildProvider buildProvider) {
|
|
|
|
// Skip source files, since their code generation is an identity transform
|
|
if (buildProvider is SourceFileBuildProvider)
|
|
return;
|
|
|
|
base.AddBuildProvider(buildProvider);
|
|
}
|
|
}
|
|
|
|
}
|