public PInvokeInfo (MethodDefinition meth, PInvokeAttributes attrs,
string entryPoint, ModuleReference mod) : this (meth)
{
m_attributes = attrs;
m_entryPoint = entryPoint;
m_module = mod;
}
internal static CilModuleReference Create(ModuleReference moduleReference, ref CilReaders readers, int token)
{
CilModuleReference reference = new CilModuleReference();
reference._readers = readers;
reference._moduleReference = moduleReference;
reference._token = token;
return reference;
}
private bool TryImportModule(string modName, bool forceAbsolute, out ModuleReference moduleRef, out IReadOnlyList <string> remainingParts)
{
moduleRef = null;
remainingParts = null;
if (ProjectState.Limits.CrossModule > 0 &&
ProjectState.ModulesByFilename.Count > ProjectState.Limits.CrossModule)
{
// too many modules loaded, disable cross module analysis by blocking
// scripts from seeing other modules.
return(false);
}
var candidates = ModuleResolver.ResolvePotentialModuleNames(_unit.ProjectEntry, modName, forceAbsolute).ToArray();
foreach (var name in candidates)
{
if (ProjectState.Modules.TryImport(name, out moduleRef))
{
return(true);
}
}
foreach (var name in candidates)
{
moduleRef = null;
foreach (var part in ModulePath.GetParents(name, includeFullName: true))
{
if (ProjectState.Modules.TryImport(part, out var mref))
{
moduleRef = mref;
if (part.Length < name.Length)
{
moduleRef.Module?.Imported(_unit);
}
}
else if (moduleRef != null)
{
Debug.Assert(moduleRef.Name.Length + 1 < name.Length, $"Expected {name} to be a child of {moduleRef.Name}");
if (moduleRef.Name.Length + 1 < name.Length)
{
remainingParts = name.Substring(moduleRef.Name.Length + 1).Split('.');
}
return(true);
}
else
{
break;
}
}
}
return(moduleRef?.Module != null);
}
public override string GetModuleDocumentation(ModuleReference modRef)
{
var contents = $"module {modRef.Name}";
var doc = modRef.Module?.Documentation;
if (!string.IsNullOrEmpty(doc))
{
doc = LimitLines(modRef.Module.Documentation);
contents += $"{Environment.NewLine}{Environment.NewLine}{doc}";
}
return(contents);
}
/// <summary>
/// Adds a single module reference to the buffer.
/// </summary>
/// <param name="reference">The reference to add.</param>
/// <returns>The new metadata token assigned to the module reference.</returns>
public MetadataToken GetModuleReferenceToken(ModuleReference reference)
{
AssertIsImported(reference);
var table = Metadata.TablesStream.GetTable <ModuleReferenceRow>(TableIndex.ModuleRef);
var row = new ModuleReferenceRow(Metadata.StringsStream.GetStringIndex(reference.Name));
var token = table.Add(row);
AddCustomAttributes(token, reference);
return(token);
}
internal void WriteModuleRef(ModuleReference moduleRef)
{
if (moduleRef.UpdateRowOnRebuild)
{
object[] parts = new object[]
{
GetHeapOffset(newStringsHeap, newStringsHeap.GetStringOffset(moduleRef.Name)),
};
moduleRef.MetaDataRow = new MetaDataRow(parts);
}
writer.Write(moduleRef.MetaDataRow.GenerateBytes());
}
private bool TryImportModule(string modName, bool forceAbsolute, out ModuleReference moduleRef, out IReadOnlyList <string> remainingParts)
{
moduleRef = null;
remainingParts = null;
if (ProjectState.Limits.CrossModule > 0 &&
ProjectState.ModulesByFilename.Count > ProjectState.Limits.CrossModule)
{
// too many modules loaded, disable cross module analysis by blocking
// scripts from seeing other modules.
return(false);
}
var candidates = ModuleResolver.ResolvePotentialModuleNames(_unit.ProjectEntry, modName, forceAbsolute).ToArray();
foreach (var name in candidates)
{
ModuleReference modRef;
bool gotAllParents = true;
AnalysisValue lastParent = null;
remainingParts = name.Split('.');
foreach (var part in ModulePath.GetParents(name, includeFullName: false))
{
if (!ProjectState.Modules.TryImport(part, out modRef))
{
gotAllParents = false;
break;
}
moduleRef = modRef;
(lastParent as BuiltinModule)?.AddChildModule(remainingParts[0], moduleRef.AnalysisModule);
lastParent = moduleRef.AnalysisModule;
remainingParts = remainingParts.Skip(1).ToArray();
}
if (gotAllParents && ProjectState.Modules.TryImport(name, out modRef))
{
moduleRef = modRef;
(lastParent as BuiltinModule)?.AddChildModule(remainingParts[0], moduleRef.AnalysisModule);
_unit.DeclaringModule.AddModuleReference(moduleRef);
remainingParts = null;
return(true);
}
}
if (moduleRef?.Module != null)
{
_unit.DeclaringModule.AddModuleReference(moduleRef);
return(true);
}
return(false);
}
private CodeFrame ReadObjectFile(ModuleReference mod, FileInfo fi)
{
var obj = new ObjectFileReader(fi.ToModuleFileInfo());
try
{
return(obj.Read());
}
catch
{
return(null);
}
}
public override string GetModuleDocumentation(ModuleReference modRef)
{
var prefix = modRef.AnalysisModule?.PythonType?.IsBuiltin == true ? "built-in module " : "module ";
var contents = $"{prefix} {modRef.Name}";
var doc = modRef.Module?.Documentation;
if (!string.IsNullOrEmpty(doc))
{
doc = LimitLines(modRef.Module.Documentation);
contents += $"{Environment.NewLine}{Environment.NewLine}{doc}";
}
return(contents);
}
public void ImportModuleReference()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var module = new ModuleReference("SomeModule");
var newModule = importer.ImportModule(module);
Assert.NotSame(module, newModule);
Assert.Equal(image, newModule.Image);
Assert.Equal(newModule.Name, newModule.Name);
}
/// <summary>
/// Determines whether two module references are considered equal according to their signature.
/// </summary>
/// <param name="reference1">The first module to compare.</param>
/// <param name="reference2">The second module to compare.</param>
/// <returns><c>True</c> if the module references are considered equal, <c>False</c> otherwise.</returns>
public bool Equals(ModuleReference reference1, ModuleReference reference2)
{
if (reference1 == null && reference2 == null)
{
return(true);
}
if (reference1 == null || reference2 == null)
{
return(false);
}
return(reference1.Name == reference2.Name);
}
private static ModuleReference GetOrAddModuleReference(ModuleDefinition module, string name)
{
var alreadyExistingModule = module.ModuleReferences.FirstOrDefault(x => x.Name == name);
if (alreadyExistingModule != null)
{
return(alreadyExistingModule);
}
var newModule = new ModuleReference(name);
module.ModuleReferences.Add(newModule);
return(newModule);
}
public void PersistentScope()
{
var map = Lookup(nameof(PlatformInvoke.ExternalMethod));
var newModule = new ModuleReference("SomeOtherDll.dll");
map.MemberForwarded.Module.ModuleReferences.Add(newModule);
map.Scope = newModule;
var newMap = RebuildAndLookup(map);
Assert.Equal(newModule.Name, newMap.Scope.Name);
}
public override object Deserialize(Cell _data, ConversionContext _context = null)
{
if (_context == null)
{
throw new ArgumentNullException("_context");
}
object data = base.Deserialize(_data);
ModuleReference moduleRef = null;
if (data == null)
{
moduleRef = new ModuleReference();
}
else
{
moduleRef = data as ModuleReference;
if (moduleRef == null)
{
moduleRef = new ModuleReference();
}
}
if (!_context.Field.Metadata.IsLoaded)
{
_context.Field.Metadata.Load();
}
// grab the module id from the field metadata
var fieldMetadata = _context.Field.Metadata.FirstOrDefault(m => m.Key == ModuleRepository.ModuleReferenceMetadataKey);
if (fieldMetadata == null ||
String.IsNullOrWhiteSpace(fieldMetadata.Value))
{
// metadata not found
return(null);
}
// at this point, we should have a JSON string containing the referenced module id
int id;
if (!Int32.TryParse(fieldMetadata.Value.Trim("\"".ToCharArray()), out id))
{
// unable to parse the referenced module id
return(null);
}
moduleRef.ModuleId = id;
return(moduleRef);
}
private MethodDefinition CopyMethod(MethodDefinition templateMethod, bool makePrivate = false)
{
var attributes = templateMethod.Attributes;
if (makePrivate)
{
attributes &= ~Mono.Cecil.MethodAttributes.Public;
attributes |= Mono.Cecil.MethodAttributes.Private;
}
var returnType = Resolve(templateMethod.ReturnType);
var newMethod = new MethodDefinition(templateMethod.Name, attributes, returnType)
{
IsPInvokeImpl = templateMethod.IsPInvokeImpl,
IsPreserveSig = templateMethod.IsPreserveSig,
};
if (templateMethod.IsPInvokeImpl)
{
var moduleRef = ModuleDefinition.ModuleReferences.FirstOrDefault(mr => mr.Name == templateMethod.PInvokeInfo.Module.Name);
if (moduleRef == null)
{
moduleRef = new ModuleReference(templateMethod.PInvokeInfo.Module.Name);
ModuleDefinition.ModuleReferences.Add(moduleRef);
}
newMethod.PInvokeInfo = new PInvokeInfo(templateMethod.PInvokeInfo.Attributes, templateMethod.PInvokeInfo.EntryPoint, moduleRef);
}
if (templateMethod.Body != null)
{
newMethod.Body.InitLocals = templateMethod.Body.InitLocals;
foreach (var variableDefinition in templateMethod.Body.Variables)
{
var newVariableDefinition = new VariableDefinition(Resolve(variableDefinition.VariableType));
//newVariableDefinition.Name = variableDefinition.Name;
newMethod.Body.Variables.Add(newVariableDefinition);
}
CopyInstructions(templateMethod, newMethod);
CopyExceptionHandlers(templateMethod, newMethod);
}
foreach (var parameterDefinition in templateMethod.Parameters)
{
var newParameterDefinition = new ParameterDefinition(Resolve(parameterDefinition.ParameterType))
{
Name = parameterDefinition.Name
};
newMethod.Parameters.Add(newParameterDefinition);
}
_targetType.Methods.Add(newMethod);
return(newMethod);
}
MethodDefinition CreateExternalMethod(MethodReference mr, string library, ModuleReference referredLibrary)
{
MethodDefinition md = new MethodDefinition(mr.Name,
MethodAttributes.PInvokeImpl | MethodAttributes.HideBySig | MethodAttributes.Private |
MethodAttributes.Static, mr.ReturnType.ReturnType);
foreach (ParameterDefinition pd in mr.Parameters)
{
md.Parameters.Add(pd);
}
md.PInvokeInfo = new PInvokeInfo(md,
PInvokeAttributes.CharSetAnsi | PInvokeAttributes.CallConvCdecl, md.Name, referredLibrary);
return(md);
}
public PlatformSpecificHelpersTypeAdder(IMetadataHost host, ITypeDefinition typeDef, ITypeReference marshalClass)
{
var libc = new ModuleReference
{
ModuleIdentity = new ModuleIdentity(host.NameTable.GetNameFor("libc"), "unknown://location")
};
var libdl = new ModuleReference
{
ModuleIdentity = new ModuleIdentity(host.NameTable.GetNameFor("libdl"), "unknown://location")
};
var libSystem = new ModuleReference
{
ModuleIdentity = new ModuleIdentity(host.NameTable.GetNameFor("libSystem"), "unknown://location")
};
var kernel32 = new ModuleReference
{
ModuleIdentity = new ModuleIdentity(host.NameTable.GetNameFor("kernel32"), "unknown://location")
};
var linux = CreateUnixSpecificHelpers(host, typeDef, "linux_", "dlopen", "dlclose", "dlsym", libdl, PInvokeCallingConvention.CDecl);
var darwin = CreateUnixSpecificHelpers(host, typeDef, "darwin_", "dlopen", "dlclose", "dlsym", libSystem, PInvokeCallingConvention.CDecl);
var bsd = CreateUnixSpecificHelpers(host, typeDef, "bsd_", "dlopen", "dlclose", "dlsym", libc, PInvokeCallingConvention.CDecl);
var windows = CreateWindowsHelpers(host, typeDef, "windows_", "LoadLibrary", "FreeLibrary", "GetProcAddress", kernel32, PInvokeCallingConvention.WinApi);
var unix = CreateUnixHelpers(host, typeDef, marshalClass, linux, darwin, bsd, libc);
this.WindowsLoaderMethods = new WindowsLoaderMethods
{
LoadLibrary = windows[0],
FreeLibrary = windows[1],
GetProcAddress = windows[2]
};
this.UnixLoaderMethods = new UnixLoaderMethods
{
LoadLibrary = unix[0],
FreeLibrary = unix[1],
GetProcAddress = unix[2]
};
this.Methods = new List <IMethodDefinition>();
this.Methods.AddRange(linux);
this.Methods.AddRange(darwin);
this.Methods.AddRange(bsd);
this.Methods.AddRange(windows);
this.Methods.AddRange(unix);
}
public Uri?TryGetLocalModuleEntryPointPath(Uri parentModuleUri, ModuleReference reference, out DiagnosticBuilder.ErrorBuilderDelegate?failureBuilder)
{
var typed = ConvertReference(reference);
var localUri = fileResolver.TryResolveFilePath(parentModuleUri, typed.Path);
if (localUri is not null)
{
failureBuilder = null;
return(localUri);
}
failureBuilder = x => x.FilePathCouldNotBeResolved(typed.Path, parentModuleUri.LocalPath);
return(null);
}
public ModuleReference convert(ModuleReference modRef)
{
foreach (var modModRef in module.ModuleReferences)
{
if (modModRef.Name == modRef.Name)
{
return(modModRef);
}
}
var newModRef = new ModuleReference(modRef.Name);
module.ModuleReferences.Add(newModRef);
return(newModRef);
}
private ModuleReference ModuleReferenceFor(string name)
{
foreach (var reference in _module_definition.ModuleReferences)
{
if (reference.Name == name)
{
return(reference);
}
}
var module = new ModuleReference(name);
_module_definition.ModuleReferences.Add(module);
return(module);
}
public static ModuleReference lookup(ModuleDefinition module, ModuleReference other, string errorMessage)
{
if (other == null)
{
return(null);
}
foreach (var modRef in module.ModuleReferences)
{
if (modRef.MetadataToken.ToInt32() == other.MetadataToken.ToInt32())
{
return(modRef);
}
}
throw new ApplicationException(errorMessage);
}
/// <summary>
/// Finishes importing a module or module member.
/// </summary>
/// <param name="module">
/// The imported module, as returned from TryImportModule.
/// </param>
/// <param name="attribute">
/// Attribute within the module to resolve, already split at
/// dots, as returned from TryImportModule.
/// </param>
/// <param name="importAs">
/// The name to save the imported module or member under.
/// </param>
/// <param name="node">
/// If <paramref name="addRef"/> is true, this node will be
/// added as a reference of the imported value.
/// </param>
/// <param name="addRef">
/// True to add <paramref name="node"/> as a reference of the
/// imported value.
/// </param>
private void FinishImportModuleOrMember(ModuleReference module, IReadOnlyList <string> attribute, string name, bool addRef, Node node, NameExpression nameReference)
{
if (AssignImportedModuleOrMember(
name,
GetImportedModuleOrMember(module, attribute, addRef, node, nameReference, attribute?.Count == 1 ? name : null),
addRef,
node,
nameReference
))
{
// Imports into our global scope need to enqueue modules that have imported us
if (Scope == GlobalScope.Scope)
{
GlobalScope.ModuleDefinition.EnqueueDependents();
}
}
}
public static ICollection <ModuleReference> GetModulesDependingOn(ICollection <TypeReference> typesDependingOn)
{
HashSet <ModuleReference> result = new HashSet <ModuleReference>();
foreach (TypeReference type in typesDependingOn)
{
if (type.Scope is ModuleReference && !(type.Scope is AssemblyNameReference || type.Scope is ModuleDefinition))
{
ModuleReference module = type.Scope as ModuleReference;
if (!result.Contains(module))
{
result.Add(module);
}
}
}
return(result);
}
internal AssemblyInformation GetOrAddAssembly(
ModuleReference moduleReference)
{
if (moduleReference == null)
{
return(default(AssemblyInformation));
}
lock (assemblyByModule)
{
if (!assemblyByModule.TryGetValue(moduleReference, out var assemblyDefinition))
{
assemblyDefinition = ((ModuleDefinition)moduleReference).Assembly;
assemblyByModule.Add(moduleReference, assemblyDefinition);
}
return(this.GetOrAddAssembly(assemblyDefinition));
}
}
public static Reflector.CodeModel.IModuleReference Cecil2Reflector(ModuleReference mr, ModuleDefinition md)
{
Reflector.CodeModel.IModule m = Cecil2Reflector(md);
if (m == null)
{
return(null);
}
string mrName = mr.Name;
foreach (Reflector.CodeModel.IModuleReference mrTmp in m.ModuleReferences)
{
if (mrTmp.Name == mrName)
{
return(mrTmp);
}
}
return(null);
}
public override void VisitModuleReference(ModuleReference module)
{
string name = module.Name;
name = name.ToLower();
if (!BaseAssemblyResolver.OnMono())
{
if (!name.EndsWith(".dll"))
{
name += ".dll";
}
}
if (!ModuleReferencesContains(target.MainModule.ModuleReferences, name))
{
module.Name = name;
target.MainModule.ModuleReferences.Add(module);
}
}
internal ModuleInformation GetOrAddModule(
ModuleReference moduleReference)
{
if (moduleReference == null)
{
return(default(ModuleInformation));
}
lock (modules)
{
if (!modules.TryGetValue(moduleReference, out var module))
{
var assembly = this.GetOrAddAssembly(moduleReference);
module = new ModuleInformation(moduleReference, assembly);
modules.Add(moduleReference, module);
}
return(module);
}
}
public override PInvokeMetadata GetPInvokeMethodMetadata()
{
if (!IsPInvoke)
{
return(default(PInvokeMetadata));
}
MetadataReader metadataReader = MetadataReader;
MethodImport import = metadataReader.GetMethodDefinition(_handle).GetImport();
string name = metadataReader.GetString(import.Name);
ModuleReference moduleRef = metadataReader.GetModuleReference(import.Module);
string moduleName = metadataReader.GetString(moduleRef.Name);
// Spot check the enums match
Debug.Assert((int)MethodImportAttributes.CallingConventionStdCall == (int)PInvokeAttributes.CallingConventionStdCall);
Debug.Assert((int)MethodImportAttributes.CharSetAuto == (int)PInvokeAttributes.CharSetAuto);
Debug.Assert((int)MethodImportAttributes.CharSetUnicode == (int)PInvokeAttributes.CharSetUnicode);
return(new PInvokeMetadata(moduleName, name, (PInvokeAttributes)import.Attributes));
}
ModuleReference GetModuleReference(ModuleReferenceCollection members, ModuleReference module)
{
string name = module.Name;
name = name.ToLower();
if (!BaseAssemblyResolver.OnMono())
{
if (!name.EndsWith(".dll"))
{
name += ".dll";
}
}
foreach (ModuleReference mr in members)
{
if (mr.Name == name)
{
return(mr);
}
}
return(null);
}
/// <summary>
/// Checks if the operand calls a native library, via PInvoke.
/// </summary>
/// <param name="operand">The operand in question.</param>
/// <returns>True if the operand is a PInvoke, otherwise false.</returns>
static bool IsPInvoke(object operand, out ModuleReference nativeLib)
{
nativeLib = null;
// try to cast operand to method definition and check for PInvoke
var mdef = operand as MethodDefinition;
if (mdef != null)
{
if (mdef.IsPInvokeImpl)
{
logger.Debug("Is PInvoke? {0}", true);
if (mdef.PInvokeInfo != null)
{
nativeLib = mdef.PInvokeInfo.Module;
logger.Debug("Native library: {0}", nativeLib.Name);
}
return(true);
}
}
return(false);
}
public void Test_Deserialize_ModuleReference()
{
// Arrange
var fakeRepo = new FakeModuleRepository();
var rowField = fakeRepo.GetRandomCell();
rowField.Field.Metadata.Add(new FieldMetadata {
Key = ModuleRepository.ModuleReferenceMetadataKey,
Value = "\"" + rowField.Field.Module.Id + "\""
});
var value = new ModuleReference()
{
Id = rowField.ID
};
var converter = FieldValueConversion.GetConverter(value.GetType());
var field = new DynamicModuleField {
Data = value
};
var rf = new Cell()
{
Data = converter.Serialize(field)
};
var retData = converter.Deserialize(rf, new ConversionContext {
Repository = fakeRepo,
Field = rowField.Field,
Module = rowField.Field.Module
});
// Assert
Assert.IsNotNull(retData);
Assert.IsInstanceOfType(retData, typeof(ModuleReference));
ModuleReference result = (ModuleReference)retData;
Assert.AreEqual(rowField.Row.ID, result.Id);
}
private bool TryImportModule(string modName, bool forceAbsolute, out ModuleReference moduleRef)
{
if (ProjectState.Limits.CrossModule != null &&
ProjectState.ModulesByFilename.Count > ProjectState.Limits.CrossModule)
{
// too many modules loaded, disable cross module analysis by blocking
// scripts from seeing other modules.
moduleRef = null;
return(false);
}
foreach (var name in PythonAnalyzer.ResolvePotentialModuleNames(_unit.ProjectEntry, modName, forceAbsolute))
{
foreach (var part in ModulePath.GetParents(name, includeFullName: false))
{
ModuleReference parentRef;
if (ProjectState.Modules.TryImport(part, out parentRef))
{
var bi = parentRef.Module as BuiltinModule;
if (bi == null)
{
break;
}
bi.Imported(_unit);
}
}
if (ProjectState.Modules.TryImport(name, out moduleRef))
{
return(true);
}
}
_unit.DeclaringModule.AddUnresolvedModule(modName, forceAbsolute);
moduleRef = null;
return(false);
}
MethodDefinition CopyMethod(MethodDefinition templateMethod, bool makePrivate = false)
{
var attributes = templateMethod.Attributes;
if (makePrivate)
{
attributes &= ~Mono.Cecil.MethodAttributes.Public;
attributes |= Mono.Cecil.MethodAttributes.Private;
}
var returnType = Resolve(templateMethod.ReturnType);
var newMethod = new MethodDefinition(templateMethod.Name, attributes, returnType)
{
IsPInvokeImpl = templateMethod.IsPInvokeImpl,
IsPreserveSig = templateMethod.IsPreserveSig,
};
if (templateMethod.IsPInvokeImpl)
{
var moduleRef = ModuleDefinition.ModuleReferences.FirstOrDefault(mr => mr.Name == templateMethod.PInvokeInfo.Module.Name);
if (moduleRef == null)
{
moduleRef = new ModuleReference(templateMethod.PInvokeInfo.Module.Name);
ModuleDefinition.ModuleReferences.Add(moduleRef);
}
newMethod.PInvokeInfo = new PInvokeInfo(templateMethod.PInvokeInfo.Attributes, templateMethod.PInvokeInfo.EntryPoint, moduleRef);
}
if (templateMethod.Body != null)
{
newMethod.Body.InitLocals = templateMethod.Body.InitLocals;
foreach (var variableDefinition in templateMethod.Body.Variables)
{
var newVariableDefinition = new VariableDefinition(Resolve(variableDefinition.VariableType));
newVariableDefinition.Name = variableDefinition.Name;
newMethod.Body.Variables.Add(newVariableDefinition);
}
CopyInstructions(templateMethod, newMethod);
CopyExceptionHandlers(templateMethod, newMethod);
}
foreach (var parameterDefinition in templateMethod.Parameters)
{
var newParameterDefinition = new ParameterDefinition(Resolve(parameterDefinition.ParameterType));
newParameterDefinition.Name = parameterDefinition.Name;
newMethod.Parameters.Add(newParameterDefinition);
}
targetType.Methods.Add(newMethod);
return newMethod;
}
public void RemoveModuleReference(ModuleReference moduleRef) {
if (_referencedModules.Remove(moduleRef)) {
moduleRef.RemoveReference(this);
}
}
MethodDefinition CopyMethod(MethodDefinition templateMethod)
{
var returnType = Resolve(templateMethod.ReturnType);
var newMethod = new MethodDefinition(templateMethod.Name, templateMethod.Attributes, returnType)
{
IsPInvokeImpl = templateMethod.IsPInvokeImpl,
IsPreserveSig = templateMethod.IsPreserveSig,
};
if (templateMethod.IsPInvokeImpl)
{
var moduleRef = new ModuleReference(templateMethod.PInvokeInfo.Module.Name);
Module.ModuleReferences.Add(moduleRef);
newMethod.PInvokeInfo = new PInvokeInfo(templateMethod.PInvokeInfo.Attributes, templateMethod.PInvokeInfo.EntryPoint, moduleRef);
}
if (templateMethod.Body != null)
{
newMethod.Body.InitLocals = templateMethod.Body.InitLocals;
foreach (var variableDefinition in templateMethod.Body.Variables)
{
newMethod.Body.Variables.Add(new VariableDefinition(Resolve(variableDefinition.VariableType)));
}
CopyInstructions(templateMethod, newMethod);
CopyExceptionHandlers(templateMethod, newMethod);
}
foreach (var parameterDefinition in templateMethod.Parameters)
{
newMethod.Parameters.Add(new ParameterDefinition(Resolve(parameterDefinition.ParameterType)));
}
targetType.Methods.Add(newMethod);
return newMethod;
}
public void Write(ModuleWriter writer)
{
// Create the header.
ModuleHeader header = new ModuleHeader();
// Populate it.
// Store the module type.
header.moduleType = (uint)moduleType;
// Write the header.
header.Write(writer);
// Prepare the members.
globalNamespace.PrepareSerialization();
foreach(ScopeMember instance in genericInstances)
instance.PrepareSerialization();
// Prepare type referemnces.
PrepareTypeReferences();
// Prepare resource writing.
PrepareResources();
// Prepare debug information.
DebugEmitter debugEmitter = null;
if(debugBuild)
{
debugEmitter = new DebugEmitter(this);
debugEmitter.Prepare();
globalNamespace.PrepareDebug(debugEmitter);
}
// Don't allow registering members.
writingModule = true;
// Write the members.
header.memberTableOffset = writer.GetPosition();
foreach(ScopeMember member in memberTable)
{
// Write local members, and a pointer for the externals.
ChelaModule memberModule = member.GetModule();
if(memberModule == this)
{
member.Write(writer);
}
else
{
// Don't write external generic instances.
if(member.GetGenericInstance() != null)
throw new ModuleException("Write external generic instance.");
// Create the member reference header.
MemberHeader mheader = new MemberHeader();
mheader.memberSize = 1;
mheader.memberName = RegisterString(member.GetFullName()); // TODO: Use mangled name.
mheader.memberType = (byte)MemberHeaderType.Reference;
// Write the reference header and module id.
mheader.Write(writer);
writer.Write((byte)AddReference(memberModule));
}
}
header.memberTableSize = writer.GetPosition() - header.memberTableOffset;
// Write module references.
header.moduleRefTableOffset = writer.GetPosition();
header.moduleRefTableEntries = (uint) (referencedModules.Count + 1);
// Write myself.
ModuleReference modRef = new ModuleReference();
modRef.moduleName = RegisterString(GetName());
modRef.Write(writer);
// Write module references.
foreach(ChelaModule mod in referencedModules)
{
modRef.moduleName = RegisterString(mod.GetName());
modRef.Write(writer);
}
// Write the libraries table.
header.libTableOffset = writer.GetPosition();
header.libTableEntries = (uint)nativeLibraries.Count;
foreach(string libname in nativeLibraries)
writer.Write(RegisterString(libname));
// Write the anonymous types.
header.anonTypeTableOffset = writer.GetPosition();
WriteAnonType(writer);
header.anonTypeTableSize = writer.GetPosition() - header.anonTypeTableOffset;
// Write the type table.
header.typeTableOffset = writer.GetPosition();
header.typeTableEntries = (uint)typeTable.Count;
TypeReference typeRef = new TypeReference();
foreach(IChelaType type in typeTable)
{
// Write the type kind.
if(type.IsTypeInstance())
typeRef.typeKind = (byte)TypeKind.Instance;
else if(type.IsStructure())
typeRef.typeKind = (byte)TypeKind.Structure;
else if(type.IsClass())
typeRef.typeKind = (byte)TypeKind.Class;
else if(type.IsInterface())
typeRef.typeKind = (byte)TypeKind.Interface;
else if(type.IsFunction())
typeRef.typeKind = (byte)TypeKind.Function;
else if(type.IsReference())
typeRef.typeKind = (byte)TypeKind.Reference;
else if(type.IsPointer())
typeRef.typeKind = (byte)TypeKind.Pointer;
else if(type.IsConstant())
typeRef.typeKind = (byte)TypeKind.Constant;
else if(type.IsArray())
typeRef.typeKind = (byte)TypeKind.Array;
else if(type.IsVector())
typeRef.typeKind = (byte)TypeKind.Vector;
else if(type.IsMatrix())
typeRef.typeKind = (byte)TypeKind.Matrix;
else if(type.IsPlaceHolderType())
typeRef.typeKind = (byte)TypeKind.PlaceHolder;
if(!type.IsStructure() && !type.IsClass() && !type.IsInterface() &&
!type.IsTypeInstance())
{
// Write a reference into the anonymous types.
typeRef.memberId = (uint)anonymousTypeMap[type];
typeRef.typeName = 0;//RegisterString(type.GetName());
}
else
{
// Write the type member reference.
ScopeMember member = (ScopeMember)type;
typeRef.memberId = RegisterMember(member);
typeRef.typeName = 0;//RegisterString(type.GetName());
}
// Write the type reference.
typeRef.Write(writer);
}
// Write the string table.
header.stringTableOffset = writer.GetPosition();
header.stringTableEntries = (uint)stringTable.Count;
foreach(string s in stringTable)
writer.Write(s);
// Write the debug info
if(debugBuild)
{
header.debugInfoOffset = writer.GetPosition();
debugEmitter.Write(writer);
header.debugInfoSize = writer.GetPosition() - header.debugInfoOffset;
}
// Write the resources.
header.resourceDataOffset = writer.GetPosition();
WriteResources(writer);
header.resourceDataSize = writer.GetPosition() - header.resourceDataOffset;
// Store the module size.
header.moduleSize = writer.GetPosition();
// Store the entry point.
if(mainFunction != null)
header.entryPoint = mainFunction.GetSerialId();
// Write the header again.
writer.MoveBegin();
header.Write(writer);
// Allow more modifications from here.
writingModule = false;
}
public PInvokeInfo(PInvokeAttributes attributes, string entryPoint, ModuleReference module)
{
this.attributes = (ushort) attributes;
this.entry_point = entryPoint;
this.module = module;
}
public void MatchModuleReferencesTest()
{
const string name = "somemodule";
var module1 = new ModuleReference(name);
var module2 = new ModuleReference(name);
var module3 = new ModuleReference(name + "1");
Assert.IsTrue(_comparer.MatchModules(module1, module2));
Assert.IsFalse(_comparer.MatchModules(module1, module3));
}
protected virtual void AddReferenceToModule(CompilerOptions options, Module module, string name, string aliases, ErrorNodeList errorNodes, TrivialHashtable previousReferences,
bool giveErrorsForDuplicateReferences, bool assemblyReference){
this.AllocateAssemblyCacheIfNeeded();
Error e = assemblyReference ? Error.NotAnAssembly : Error.NotAModule;
string aname = name;
string fname = System.IO.Path.GetFileName(aname);
string ext = System.IO.Path.GetExtension(fname);
bool providedDefaultExtension = false;
if (assemblyReference){
if (ext.ToLower(CultureInfo.InvariantCulture) != ".dll" && ext.ToLower(CultureInfo.InvariantCulture) != ".exe"){
aname = aname+".dll";
fname = fname+".dll";
providedDefaultExtension = true;
}
}else{
if (ext.ToLower(CultureInfo.InvariantCulture) != ".netmodule"){
aname = aname+".netmodule";
fname = fname+".netmodule";
providedDefaultExtension = true;
}
}
Module rModule = null;
if (providedDefaultExtension)
rModule = this.GetModuleFromReferencedCompilation(name);
if (rModule == null)
rModule = this.GetModuleFromReferencedCompilation(aname);
if (rModule == null){
e = Error.NoSuchFile;
if (fname == aname){//Simple name, let compiler probe for it
if (providedDefaultExtension) {
aname = this.GetFullyQualifiedNameForReferencedLibrary(options, name);
if (aname == null)
aname = this.GetFullyQualifiedNameForReferencedLibrary(options, aname);
}else
aname = this.GetFullyQualifiedNameForReferencedLibrary(options, aname);
if (aname == null) goto error;
}else{
if (!System.IO.File.Exists(aname)){
if (!System.IO.File.Exists(name)) goto error;
aname = name;
}
}
rModule = Module.GetModule(aname, this.AssemblyCache, !options.MayLockFiles, options.LoadDebugSymbolsForReferencedAssemblies, true);
if (rModule == null) goto error;
e = assemblyReference ? Error.NotAnAssembly : Error.NotAModule;
}
AssemblyNode rAssem = rModule as AssemblyNode;
if (rAssem != null){
if (!assemblyReference) goto error;
}else{
if (assemblyReference) goto error;
}
Node prevRef = previousReferences[rModule.UniqueKey] as Node;
AssemblyReference aref = prevRef as AssemblyReference;
if (prevRef != null) {
if (aref == null || aliases == null || aliases.Length == 0){
if (!giveErrorsForDuplicateReferences) return;
e = assemblyReference ? Error.DuplicateAssemblyReference : Error.DuplicateModuleReference;
goto error;
}
}
if (assemblyReference){
if (aref == null) aref = new AssemblyReference(rAssem);
if (aliases != null && aliases.Length > 0){
if (aref.Aliases == null) aref.Aliases = new IdentifierList();
string[] aliasArr = aliases.Split(',');
foreach (string alias in aliasArr)
if (alias != null && alias.Length > 0) aref.Aliases.Add(Identifier.For(alias));
}
module.AssemblyReferences.Add(aref);
previousReferences[rModule.UniqueKey] = aref;
}else{
ModuleReference mref = new ModuleReference(name, rModule);
module.ModuleReferences.Add(mref);
previousReferences[rModule.UniqueKey] = mref;
}
return;
error:
errorNodes.Add(this.CreateErrorNode(e, name));
}
public override ModuleReference VisitModuleReference(ModuleReference moduleReference)
{
throw new ApplicationException("unimplemented");
}
internal Microsoft.Cci.IModuleReference Translate(ModuleSymbol module)
{
if (ReferenceEquals(sourceModule, module))
{
return this;
}
object reference;
if (SymbolsMap.TryGetValue(module, out reference))
{
return (Microsoft.Cci.IModuleReference)reference;
}
Microsoft.Cci.IModuleReference moduleRef;
AssemblySymbol container = module.ContainingAssembly;
if (container != null && ReferenceEquals(container.Modules[0], module))
{
moduleRef = new AssemblyReference(container);
SymbolsMap.Add(container, moduleRef);
}
else
{
moduleRef = new ModuleReference(this, module);
}
SymbolsMap.Add(module, moduleRef);
return moduleRef;
}
MethodDefinition CopyMethod(MethodDefinition sourceMethod, TypeDefinition source, TypeDefinition target, bool signatureOnly, bool makePrivate = false)
{
var newMethod = (from method in target.Methods
where string.Equals(sourceMethod.Name, method.Name)
select method).FirstOrDefault();
var isExistingMethod = (newMethod != null);
if (!isExistingMethod)
{
var attributes = sourceMethod.Attributes;
if (makePrivate)
{
attributes &= ~Mono.Cecil.MethodAttributes.Public;
attributes |= Mono.Cecil.MethodAttributes.Private;
}
var returnType = Resolve(sourceMethod.ReturnType);
newMethod = new MethodDefinition(sourceMethod.Name, attributes, returnType)
{
IsPInvokeImpl = sourceMethod.IsPInvokeImpl,
IsPreserveSig = sourceMethod.IsPreserveSig,
};
if (sourceMethod.IsPInvokeImpl)
{
var moduleRef = ModuleDefinition.ModuleReferences.FirstOrDefault(mr => mr.Name == sourceMethod.PInvokeInfo.Module.Name);
if (moduleRef == null)
{
moduleRef = new ModuleReference(sourceMethod.PInvokeInfo.Module.Name);
ModuleDefinition.ModuleReferences.Add(moduleRef);
}
newMethod.PInvokeInfo = new PInvokeInfo(sourceMethod.PInvokeInfo.Attributes, sourceMethod.PInvokeInfo.EntryPoint, moduleRef);
}
}
if (!signatureOnly && sourceMethod.Body != null)
{
newMethod.Body.InitLocals = sourceMethod.Body.InitLocals;
foreach (var variableDefinition in sourceMethod.Body.Variables)
{
var newVariableDefinition = new VariableDefinition(Resolve(variableDefinition.VariableType));
newVariableDefinition.Name = variableDefinition.Name;
newMethod.Body.Variables.Add(newVariableDefinition);
}
CopyInstructions(sourceMethod, newMethod, source, target);
CopyExceptionHandlers(sourceMethod, newMethod);
}
if (!isExistingMethod)
{
foreach (var parameterDefinition in sourceMethod.Parameters)
{
var newParameterDefinition = new ParameterDefinition(Resolve(parameterDefinition.ParameterType));
newParameterDefinition.Name = parameterDefinition.Name;
newMethod.Parameters.Add(newParameterDefinition);
}
target.Methods.Add(newMethod);
}
return newMethod;
}
public virtual Module GetModuleFor(string modName) {
if (this.currentModule == null) return null;
ModuleReferenceList rMods = this.currentModule.ModuleReferences;
ModuleReference rMod = null;
if (rMods == null)
rMods = this.currentModule.ModuleReferences = new ModuleReferenceList();
else {
for (int i = 0, n = rMods.Count; i < n; i++) {
rMod = rMods[i];
if (rMod == null) continue;
if (rMod.Name == modName) return rMod.Module;
}
}
Module mod = new Module();
mod.Name = modName;
mod.Kind = ModuleKindFlags.UnmanagedDynamicallyLinkedLibrary;
rMod = new ModuleReference(modName, mod);
rMods.Add(rMod);
return mod;
}
public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference){
return moduleReference;
}
public virtual void VisitModuleReference(ModuleReference moduleReference)
{
}
/// <summary>
/// Determines whether two module references are considered equal according to their signature.
/// </summary>
/// <param name="reference1">The first module to compare.</param>
/// <param name="reference2">The second module to compare.</param>
/// <returns><c>True</c> if the module references are considered equal, <c>False</c> otherwise.</returns>
public bool MatchModules(ModuleReference reference1, ModuleReference reference2)
{
if (reference1 == null && reference2 == null)
return true;
if (reference1 == null || reference2 == null)
return false;
return reference1.Name == reference2.Name;
}
/// <summary>
/// Populates the list of module references.
/// </summary>
void LoadModuleReferences()
//^ ensures this.ModuleReferenceArray != null;
{
uint numberOfModuleReferences = this.PEFileReader.ModuleRefTable.NumberOfRows;
ModuleReference[] moduleRefList = new ModuleReference[numberOfModuleReferences + 1];
for (uint i = 1; i <= numberOfModuleReferences; ++i) {
ModuleRefRow moduleRefRow = this.PEFileReader.ModuleRefTable[i];
IName moduleRefName = this.GetNameFromOffset(moduleRefRow.Name);
ModuleIdentity moduleIdentity;
if (this.ContainingAssembly == null) {
moduleIdentity = new ModuleIdentity(moduleRefName, string.Empty);
} else {
moduleIdentity = new ModuleIdentity(moduleRefName, string.Empty, this.ContainingAssembly.AssemblyIdentity);
}
ModuleIdentity probedModuleIdentity = this.ModuleReader.metadataReaderHost.ProbeModuleReference(this.Module, moduleIdentity);
uint internedModuleId = (uint)this.ModuleReader.metadataReaderHost.InternFactory.GetModuleInternedKey(probedModuleIdentity);
ModuleReference moduleReference = new ModuleReference(this, i, internedModuleId, probedModuleIdentity);
moduleRefList[i] = moduleReference;
}
//^ NonNullType.AssertInitialized(moduleRefList);
this.ModuleReferenceArray = moduleRefList;
}
public virtual Differences VisitModuleReference(ModuleReference moduleReference1, ModuleReference moduleReference2){
Differences differences = new Differences(moduleReference1, moduleReference2);
if (moduleReference1 == null || moduleReference2 == null){
if (moduleReference1 != moduleReference2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
ModuleReference changes = (ModuleReference)moduleReference2.Clone();
ModuleReference deletions = (ModuleReference)moduleReference2.Clone();
ModuleReference insertions = (ModuleReference)moduleReference2.Clone();
if (moduleReference1.Name == moduleReference2.Name) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
// Caller should lock this.
internal Module/*?*/ ResolveModuleRefReference(
ModuleReference moduleReference
) {
// If this is an assembly try to find in referred modules
if (this.PEFileReader.IsAssembly) {
Assembly/*?*/ assem = this.Module as Assembly;
//^ assert assem != null;
int moduleKey = moduleReference.ModuleIdentity.Name.UniqueKeyIgnoringCase;
Module[] containigModules = assem.MemberModules.RawArray;
for (int i = 0; i < containigModules.Length; ++i) {
Module mod = containigModules[i];
if (mod.ModuleName.UniqueKeyIgnoringCase == moduleKey)
return mod;
}
}
// If not found or its not an assembly look else where...
Module/*?*/ module = this.ModuleReader.LookupModule(this.Module, moduleReference.ModuleIdentity);
return module;
}
public static ChelaModule LoadModule(ModuleReader reader, bool fullLoad)
{
// Try to guess the file type.
uint moduleStart = reader.GetPosition();
byte[] signature;
reader.Read(out signature, 8);
// Check for elf file type.
bool isElf = true;
for(int i = 0; i < 4; ++i)
{
if(signature[i] != ElfFormat.ElfMagic[i])
{
isElf = false;
break;
}
}
// Check for PE.
bool isPE = signature[0] == 'M' && signature[1] == 'Z';
// Find the module content.
reader.SetPosition(moduleStart);
if(isElf)
{
// Move to the embedded module.
ElfFormat.GetEmbeddedModule(reader);
reader.FixBase();
}
else if(isPE)
{
// Move to the embedded module.
PEFormat.GetEmbeddedModule(reader);
reader.FixBase();
}
// Read the module header.
ModuleHeader header = new ModuleHeader();
header.Read(reader);
// Create the output module.
ChelaModule result = new ChelaModule();
// Read the string table.
reader.SetPosition(header.stringTableOffset);
for(uint i = 0; i < header.stringTableEntries; ++i)
{
uint id = i+1u;
string s = reader.ReadString();
result.stringTable.Add(s);
result.registeredStrings.Add(s, id);
}
// Read myself data.
ModuleReference modref = new ModuleReference();
reader.SetPosition(header.moduleRefTableOffset);
modref.Read(reader);
result.SetName(result.GetString(modref.moduleName));
// Read the module type.
result.moduleType = (ModuleType)header.moduleType;
// Read the referenced modules.
for(uint i = 1; i < header.moduleRefTableEntries; ++i)
{
// Read the referenced module.
modref.Read(reader);
// Load it.
ChelaModule referencedModule = LoadNamedModule(result.GetString(modref.moduleName));
result.referencedModules.Add(referencedModule);
}
// Preload the members.
reader.SetPosition(header.memberTableOffset);
uint end = header.memberTableOffset + header.memberTableSize;
MemberHeader mheader = new MemberHeader();
while(reader.GetPosition() < end)
{
// Read the member header.
mheader.Read(reader);
// Skip the attributes.
SkipAttributes(reader, mheader.memberAttributes);
// Preload the member.
MemberHeaderType mtype = (MemberHeaderType)mheader.memberType;
switch(mtype)
{
case MemberHeaderType.Namespace:
Namespace.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Structure:
Structure.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Class:
Class.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Interface:
Interface.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Function:
Function.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Field:
FieldVariable.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.FunctionGroup:
FunctionGroup.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.TypeInstance:
StructureInstance.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Property:
PropertyVariable.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Event:
EventVariable.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.TypeName:
TypeNameMember.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.MemberInstance:
case MemberHeaderType.FunctionInstance:
// Ignore the member instance.
result.memberTable.Add(null);
reader.Skip(mheader.memberSize);
break;
case MemberHeaderType.TypeGroup:
TypeGroup.PreloadMember(result, reader, mheader);
break;
case MemberHeaderType.Reference:
{
// Read the module id.
byte moduleId = reader.ReadByte();
// Get the referenced module.
ChelaModule refMod = result.GetReferenced(moduleId);
// Find the member there.
ScopeMember member = refMod.GetMember(result.GetString(mheader.memberName));
result.memberTable.Add(member);
}
break;
default:
// Unknown member.
System.Console.WriteLine("add unknown member {0}", mtype);
result.memberTable.Add(null);
reader.Skip(mheader.memberSize);
break;
}
}
// Read the type table.
reader.SetPosition(header.typeTableOffset);
for(uint i = 0; i < header.typeTableEntries; ++i)
{
// Read the type reference.
TypeReference typeRef = new TypeReference();
typeRef.Read(reader);
// Try to load direct members.
TypeKind kind = (ChelaModule.TypeKind)typeRef.typeKind;
if(kind == TypeKind.Class || kind == TypeKind.Interface ||
kind == TypeKind.Structure || kind == TypeKind.Instance)
{
// Store the actual type.
result.typeTable.Add(result.GetMember(typeRef.memberId));
}
else
{
// Store the reference for delayed loading.
result.typeTable.Add(typeRef);
}
}
// Read the anonymous types.
reader.SetPosition(header.anonTypeTableOffset);
end = header.anonTypeTableOffset + header.anonTypeTableSize;
while(reader.GetPosition() < end)
{
// Read the anonymous type data.
AnonTypeHeader anonType = new AnonTypeHeader();
anonType.Read(reader);
// Store it in the anonymous type table.
result.anonymousTypes.Add(anonType);
}
// Now, read the actual members.
reader.SetPosition(header.memberTableOffset);
for(int i = 0; i < result.memberTable.Count; ++i)
{
// Get the preloaded member.
ScopeMember member = result.memberTable[i];
// Read his header.
mheader.Read(reader);
// Skip the attributes.
SkipAttributes(reader, mheader.memberAttributes);
// Read the member.
if(member != null && mheader.memberType != (int)MemberHeaderType.Reference)
member.Read(reader, mheader);
else
reader.Skip(mheader.memberSize); // Skip unknown members.
}
// The first member must be the global namespace.
result.globalNamespace = (Namespace)result.GetMember(1);
// Update the parent children relationship.
result.globalNamespace.UpdateParent(null);
// Now, perform second read pass, required by function groups.
reader.SetPosition(header.memberTableOffset);
for(int i = 0; i < result.memberTable.Count; ++i)
{
// Get the preloaded member.
ScopeMember member = result.memberTable[i];
// Read his header.
mheader.Read(reader);
// Skip the attributes.
SkipAttributes(reader, mheader.memberAttributes);
// Read the member.
if(member != null && mheader.memberType != (int)MemberHeaderType.Reference)
member.Read2(reader, mheader);
else
reader.Skip(mheader.memberSize); // Skip unknown members.
}
// Finish all of the loading.
result.globalNamespace.FinishLoad();
// Register the member names.
for(int i = 0; i < result.memberTable.Count; ++i)
{
ScopeMember member = result.memberTable[i];
if(member != null)
result.memberNameTable[member.GetFullName()] = member;
}
// Load the runtime classes.
if(result.referencedModules.Count == 0)
result.LoadRuntimeReferences(result);
// Dump the readed module.
//result.Dump();
// Return the result module.
return result;
}
public ModuleReference ImportModule(ModuleReference reference)
{
var table = _tableStreamBuffer.GetTable<ModuleReference>();
var newReference = table.FirstOrDefault(x => _signatureComparer.MatchModules(x, reference));
if (newReference == null)
table.Add(newReference = new ModuleReference(reference.Name));
return newReference;
}
public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference1, ModuleReference moduleReference2)
{
return moduleReference1;
}
public void AddModuleReference(ModuleReference moduleRef) {
if (moduleRef == null) {
Debug.Fail("moduleRef should never be null");
throw new ArgumentNullException("moduleRef");
}
_referencedModules.Add(moduleRef);
moduleRef.AddReference(this);
}
public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference, ModuleReference changes, ModuleReference deletions, ModuleReference insertions){
this.UpdateSourceContext(moduleReference, changes);
if (moduleReference == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return moduleReference;
}
public override ModuleReference VisitModuleReference(ModuleReference moduleReference)
{
if (moduleReference == null) return null;
return base.VisitModuleReference((ModuleReference)moduleReference.Clone());
}
