mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
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);
|
|
}
|
|
}
|
|
|
|
}
|