public Specializer(Module targetModule, TypeNodeList pars, TypeNodeList args){ Debug.Assert(pars != null && pars.Count > 0); Debug.Assert(args != null && args.Count > 0); this.pars = pars; this.args = args; this.TargetModule = targetModule; }
/// <param name="module">The module into which the duplicate IR will be grafted.</param> /// <param name="type">The type into which the duplicate Member will be grafted. Ignored if entire type, or larger unit is duplicated.</param> public Duplicator(Module/*!*/ module, TypeNode type) { this.TargetModule = module; this.TargetType = this.OriginalTargetType = type; this.DuplicateFor = new TrivialHashtable(); this.TypesToBeDuplicated = new TrivialHashtable(); //^ base(); }
public SnippetParser(IParserFactory/*!*/ defaultParserFactory, Module symbolTable, ErrorNodeList errorNodes, CompilerParameters options) { this.DefaultParserFactory = defaultParserFactory; this.ErrorNodes = errorNodes; this.SymbolTable = symbolTable; this.Options = options; this.CurrentStatementList = new StatementList(0); //^ base(); }
public virtual Module VisitModule(Module module){ if (module == null) return null; module.Attributes = this.VisitAttributeList(module.Attributes); module.Types = this.VisitTypeNodeList(module.Types); return module; }
public MethodBodySpecializer(Module module, TypeNodeList pars, TypeNodeList args) : base(module, pars, args){ //^ base; }
public virtual void VisitModule(Module module) { if (module == null) return; this.VisitAttributeList(module.Attributes); this.VisitTypeNodeList(module.Types); }
public virtual Module VisitModuleReference(Module module) { if (module == null) return null; Module dup = (Module)this.DuplicateFor[module.UniqueKey]; if (dup != null) return dup; for (int i = 0, n = this.TargetModule.ModuleReferences == null ? 0 : this.TargetModule.ModuleReferences.Count; i < n; i++) { //^ assert this.TargetModule.ModuleReferences != null; ModuleReference modRef = this.TargetModule.ModuleReferences[i]; if (modRef == null) continue; if (string.Compare(module.Name, modRef.Name, true, System.Globalization.CultureInfo.InvariantCulture) != 0) continue; this.DuplicateFor[module.UniqueKey] = modRef.Module; return modRef.Module; } if (this.TargetModule.ModuleReferences == null) this.TargetModule.ModuleReferences = new ModuleReferenceList(); this.TargetModule.ModuleReferences.Add(new ModuleReference(module.Name, module)); this.DuplicateFor[module.UniqueKey] = module; return module; }
public override Module VisitModule(Module module) { if (module == null) return null; Module dup = (Module)module.Clone(); if (this.TargetModule == null) this.TargetModule = dup; this.FindTypesToBeDuplicated(module.Types); return base.VisitModule(dup); }
private void ProvideTypeMembers(TypeNode/*!*/ dup, object/*!*/ handle) { TypeNode template = (TypeNode)handle; Debug.Assert(!template.membersBeingPopulated); TypeNode savedTargetType = this.TargetType; Module savedTargetModule = this.TargetModule; this.TargetType = dup; //^ assume dup.DeclaringModule != null; this.TargetModule = dup.DeclaringModule; this.FindTypesToBeDuplicated(template.NestedTypes); dup.Members = this.VisitMemberList(template.Members); DelegateNode delegateNode = dup as DelegateNode; if (delegateNode != null && delegateNode.IsNormalized) { Debug.Assert(dup.Members != null && dup.Members.Count > 0 && dup.Members[0] != null); delegateNode.Parameters = this.VisitParameterList(delegateNode.Parameters); delegateNode.ReturnType = this.VisitTypeReference(delegateNode.ReturnType); } this.TargetModule = savedTargetModule; this.TargetType = savedTargetType; }
private void ProvideNestedTypes(TypeNode/*!*/ dup, object/*!*/ handle) { TypeNode template = (TypeNode)handle; TypeNode savedTargetType = this.TargetType; Module savedTargetModule = this.TargetModule; this.TargetType = dup; //^ assume dup.DeclaringModule != null; this.TargetModule = dup.DeclaringModule; this.FindTypesToBeDuplicated(template.NestedTypes); dup.NestedTypes = this.VisitNestedTypes(dup, template.NestedTypes); this.TargetModule = savedTargetModule; this.TargetType = savedTargetType; }
public static void Initialize(bool doNotLockFile, bool getDebugInfo, Module.AssemblyReferenceResolver initialResolver) { if (CoreSystemTypes.Initialized) CoreSystemTypes.Clear(); if (SystemAssembly == null) SystemAssembly = CoreSystemTypes.GetSystemAssembly(doNotLockFile, getDebugInfo); if (initialResolver != null) SystemAssembly.AssemblyReferenceResolution += initialResolver; if (SystemAssembly == null) throw new InvalidOperationException(ExceptionStrings.InternalCompilerError); if (TargetPlatform.TargetVersion == null) { TargetPlatform.TargetVersion = SystemAssembly.Version; if (TargetPlatform.TargetVersion == null) TargetPlatform.TargetVersion = typeof(object).Module.Assembly.GetName().Version; } if (TargetPlatform.TargetVersion != null) { if (TargetPlatform.TargetVersion.Major > 1 || TargetPlatform.TargetVersion.Minor > 1 || (TargetPlatform.TargetVersion.Minor == 1 && TargetPlatform.TargetVersion.Build == 9999)) { if (SystemAssembly.IsValidTypeName(StandardIds.System, Identifier.For("Nullable`1"))) TargetPlatform.GenericTypeNamesMangleChar = '`'; else if (SystemAssembly.IsValidTypeName(StandardIds.System, Identifier.For("Nullable!1"))) TargetPlatform.GenericTypeNamesMangleChar = '!'; else if (TargetPlatform.TargetVersion.Major == 1 && TargetPlatform.TargetVersion.Minor == 2) TargetPlatform.GenericTypeNamesMangleChar = (char)0; } } InitializeSystemTypes(); }
public static void Initialize(bool doNotLockFile, bool getDebugInfo, Module.AssemblyReferenceResolver initialResolver){ if (SystemTypes.Initialized){ SystemTypes.Clear(); CoreSystemTypes.Initialize(doNotLockFile, getDebugInfo, initialResolver); #if ExtendedRuntime ExtendedRuntimeTypes.Initialize(doNotLockFile, getDebugInfo); #endif }else if (!CoreSystemTypes.Initialized){ CoreSystemTypes.Initialize(doNotLockFile, getDebugInfo, initialResolver); #if ExtendedRuntime ExtendedRuntimeTypes.Clear(); ExtendedRuntimeTypes.Initialize(doNotLockFile, getDebugInfo); #endif } if (TargetPlatform.TargetVersion == null){ TargetPlatform.TargetVersion = SystemAssembly.Version; if (TargetPlatform.TargetVersion == null) TargetPlatform.TargetVersion = typeof(object).Module.Assembly.GetName().Version; } InitializeSystemTypes(SystemAssembly); }
/// <param name="module">The module into which the duplicate IR will be grafted.</param> /// <param name="type">The type into which the duplicate Member will be grafted. Ignored if entire type, or larger unit is duplicated.</param> public Duplicator(Module/*!*/ module, TypeNode type) : this(module, type, 4) { }
private void ProvideTypeMembers(TypeNode/*!*/ dup, object/*!*/ handle) { TypeNode template = (TypeNode)handle; Debug.Assert(!template.membersBeingPopulated); TypeNode savedTargetType = this.TargetType; Module savedTargetModule = this.TargetModule; this.TargetType = dup; //^ assume dup.DeclaringModule != null; this.TargetModule = dup.DeclaringModule; //if (!this.RecordOriginalAsTemplate) this.FindTypesToBeDuplicated(template.NestedTypes); dup.Members = this.VisitMemberList(template.Members); DelegateNode delegateNode = dup as DelegateNode; if (delegateNode != null && delegateNode.IsNormalized){ Debug.Assert(dup.Members != null && dup.Members.Count > 0 && dup.Members[0] != null); DelegateNode templateDelegateNode = template as DelegateNode; delegateNode.Parameters = this.VisitParameterList(templateDelegateNode.Parameters); delegateNode.ReturnType = this.VisitTypeReference(templateDelegateNode.ReturnType); } #if ExtendedRuntime || CodeContracts dup.Contract = this.VisitTypeContract(template.Contract); #endif this.TargetModule = savedTargetModule; this.TargetType = savedTargetType; }
private void ProvideTypeSignature(TypeNode/*!*/ dup, object/*!*/ handle) { TypeNode type = (TypeNode)handle; TypeNode savedTargetType = this.TargetType; this.TargetType = dup; this.TargetModule = dup.DeclaringModule; // There could be type instantiations of this thing during the following visits. // They need to know what type parameters we have. // Null check is here so if someone copies a type and then immediately updates the template parameters // we don't override it if (!this.RecordOriginalAsTemplate && dup.templateParameters == null) { dup.TemplateParameters = this.VisitTypeReferenceList(type.TemplateParameters); } if (dup.DeclaringType == null && !(dup is ITypeParameter)) { var originalDeclaringType = type.DeclaringType; var declaringType = this.VisitTypeReference(originalDeclaringType); if (originalDeclaringType != null && (declaringType == null || declaringType == originalDeclaringType)) { dup.DeclaringType = this.OriginalTargetType; } else { dup.DeclaringType = declaringType; } } Class c = dup as Class; if (c != null && c.baseClass == null) { Class templateClass = (Class)type; c.BaseClass = (Class)this.VisitTypeReference(templateClass.BaseClass); } dup.Interfaces = this.VisitInterfaceReferenceList(type.Interfaces); this.TargetType = savedTargetType; }