public static string FullName(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(TypeHelper.GetTypeName(type, NameFormattingOptions.TypeParameters)); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(MemberHelper.GetMemberSignature(member, NameFormattingOptions.TypeParameters | NameFormattingOptions.Signature)); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(TypeHelper.GetNamespaceName(ns, NameFormattingOptions.None)); } INamedEntity named = reference as INamedEntity; if (named != null) { return(named.Name.Value); } Contract.Assert(false, String.Format(CultureInfo.CurrentCulture, LocalizedStrings.FellThroughCasesIn, "TypeExtensions.FullName()", reference.GetType())); return(LocalizedStrings.UnknownReferenceType); }
public static string RefDocId(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(type.DocId()); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(member.DocId()); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(ns.DocId()); } IAssemblyReference assembly = reference as IAssemblyReference; if (assembly != null) { return(assembly.DocId()); } Contract.Assert(false, string.Format("Fell through cases in TypeExtensions.RefDocId() Type of reference: {0}", reference.GetType())); return("<Unknown Reference Type>"); }
public static string FullName(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(TypeHelper.GetTypeName(type, NameFormattingOptions.TypeParameters)); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(MemberHelper.GetMemberSignature(member, NameFormattingOptions.TypeParameters | NameFormattingOptions.Signature)); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(TypeHelper.GetNamespaceName(ns, NameFormattingOptions.None)); } INamedEntity named = reference as INamedEntity; if (named != null) { return(named.Name.Value); } Contract.Assert(false, String.Format("Fell through cases in TypeExtensions.FullName() Type of reference: {0}", reference.GetType())); return("<Unknown Reference Type>"); }
public static string UniqueId(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(type.DocId()); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(member.DocId()); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(ns.DocId()); } IAssemblyReference assembly = reference as IAssemblyReference; if (assembly != null) { return(assembly.DocId()); } // Include the hash code as well to make it unique so we can use this for a key return("<Unknown Reference Type>" + reference.GetHashCode().ToString()); }
public static string RefDocId(this IReference reference) { Contract.Requires(reference != null); ITypeReference type = reference as ITypeReference; if (type != null) { return(type.DocId()); } ITypeMemberReference member = reference as ITypeMemberReference; if (member != null) { return(member.DocId()); } IUnitNamespaceReference ns = reference as IUnitNamespaceReference; if (ns != null) { return(ns.DocId()); } IAssemblyReference assembly = reference as IAssemblyReference; if (assembly != null) { return(assembly.DocId()); } Contract.Assert(false, string.Format(CultureInfo.CurrentUICulture, LocalizedStrings.FellThroughCasesIn, "DocIdExtensions.RefDocId()", reference.GetType())); return(LocalizedStrings.UnknownReferenceType); }
public override void Visit(IUnitNamespaceReference unitNamespaceReference) { if (Process(unitNamespaceReference)) { visitor.Visit(unitNamespaceReference); } base.Visit(unitNamespaceReference); }
private void AddUpwardNamespace(IUnitNamespaceReference iUnitNamespaceReference) { this.thingsToKeep.Add(iUnitNamespaceReference); var nested = iUnitNamespaceReference as INestedUnitNamespaceReference; if (nested != null) { this.AddUpwardNamespace(nested.ContainingUnitNamespace); } }
/// <summary> /// Returns a unit namespace definition, nested in the given unitNamespace if possible, /// otherwise nested in the given unit if possible, otherwise nested in the given host if possible, otherwise it returns Dummy.UnitNamespace. /// If unitNamespaceReference is a root namespace, the result is equal to the given unitNamespace if not null, /// otherwise the result is the root namespace of the given unit if not null, /// otherwise the result is root namespace of unitNamespaceReference.Unit, if that can be resolved via the given host, /// otherwise the result is Dummy.UnitNamespace. /// </summary> public static IUnitNamespace Resolve(IUnitNamespaceReference unitNamespaceReference, IMetadataHost host, IUnit unit = null, IUnitNamespace unitNamespace = null) { Contract.Requires(unitNamespaceReference != null); Contract.Requires(host != null); Contract.Requires(unit != null || unitNamespace == null); Contract.Ensures(Contract.Result <IUnitNamespace>() != null); var rootNsRef = unitNamespaceReference as IRootUnitNamespaceReference; if (rootNsRef != null) { if (unitNamespace != null) { return(unitNamespace); } if (unit != null) { return(unit.UnitNamespaceRoot); } unit = UnitHelper.Resolve(unitNamespaceReference.Unit, host); if (unit is Dummy) { return(Dummy.UnitNamespace); } return(unit.UnitNamespaceRoot); } var nestedNsRef = unitNamespaceReference as INestedUnitNamespaceReference; if (nestedNsRef == null) { return(Dummy.UnitNamespace); } var containingNsDef = UnitHelper.Resolve(nestedNsRef.ContainingUnitNamespace, host, unit, unitNamespace); if (containingNsDef is Dummy) { return(Dummy.UnitNamespace); } foreach (var nsMem in containingNsDef.GetMembersNamed(nestedNsRef.Name, ignoreCase: false)) { var neNsDef = nsMem as INestedUnitNamespace; if (neNsDef != null) { return(neNsDef); } } return(Dummy.UnitNamespace); }
private static void WriteNamespaceAndSeparator(IUnitNamespaceReference ns, TextWriter writer) { Contract.Requires(ns != null); Contract.Requires(writer != null); INestedUnitNamespaceReference nested = ns as INestedUnitNamespaceReference; if (nested == null) { return; // top-level } Contract.Assume(nested.ContainingUnitNamespace != null, "lack of CCI2 contracts"); WriteNamespaceAndSeparator(nested.ContainingUnitNamespace, writer); writer.Write(nested.Name.Value); writer.Write("."); }
/// <summary> /// Returns true if the given two unit namespaces are to be considered equivalent as containers. /// </summary> public static bool UnitNamespacesAreEquivalent(IUnitNamespaceReference /*?*/ unitNamespace1, IUnitNamespaceReference /*?*/ unitNamespace2) { if (unitNamespace1 == null || unitNamespace2 == null) { return(false); } if (unitNamespace1 == unitNamespace2) { return(true); } INestedUnitNamespaceReference /*?*/ nstUnitNamespace1 = unitNamespace1 as INestedUnitNamespaceReference; INestedUnitNamespaceReference /*?*/ nstUnitNamespace2 = unitNamespace2 as INestedUnitNamespaceReference; if (nstUnitNamespace1 != null && nstUnitNamespace2 != null) { return(nstUnitNamespace1.Name.UniqueKey == nstUnitNamespace2.Name.UniqueKey && UnitHelper.UnitNamespacesAreEquivalent(nstUnitNamespace1.ContainingUnitNamespace, nstUnitNamespace2.ContainingUnitNamespace)); } if (nstUnitNamespace1 != null || nstUnitNamespace2 != null) { return(false); } return(UnitHelper.UnitsAreContainmentEquivalent(unitNamespace1.Unit, unitNamespace2.Unit)); }
public IUnitNamespaceReference Map(INamespaceSymbol namespaceSymbol) { Contract.Requires(namespaceSymbol != null); Contract.Ensures(Contract.Result <IUnitNamespaceReference>() != null); IUnitNamespaceReference nsr = null; if (!namespaceSymbolCache.TryGetValue(namespaceSymbol, out nsr)) { if (namespaceSymbol.ContainingAssembly.Equals(this.assemblyBeingTranslated)) { var n = this.CreateNamespaceDefinition(namespaceSymbol); return(n); } if (namespaceSymbol.IsGlobalNamespace) { var n = new Microsoft.Cci.MutableCodeModel.RootUnitNamespaceReference() { Unit = Map(namespaceSymbol.ContainingAssembly), }; nsr = n; } else { var ns = new Microsoft.Cci.MutableCodeModel.NestedUnitNamespaceReference() { ContainingUnitNamespace = Map(namespaceSymbol.ContainingNamespace), Name = this.nameTable.GetNameFor(namespaceSymbol.Name), }; nsr = ns; } namespaceSymbolCache[namespaceSymbol] = nsr; } Contract.Assume(nsr != null); return(nsr); }
uint GetNamespaceTypeReferenceInternId(IUnitNamespaceReference containingUnitNamespace, IName typeName, uint genericParameterCount) { Contract.Requires(containingUnitNamespace != null); Contract.Requires(typeName != null); uint containingUnitNamespaceInteredId = this.GetUnitNamespaceInternId(containingUnitNamespace); foreach (NamespaceTypeStore nsTypeStore in this.NamespaceTypeHashtable.GetValuesFor((uint)typeName.UniqueKey)) { if (nsTypeStore.ContainingNamespaceInternedId == containingUnitNamespaceInteredId && nsTypeStore.GenericParameterCount == genericParameterCount) { return nsTypeStore.InternedId; } } NamespaceTypeStore nsTypeStore1 = new NamespaceTypeStore(containingUnitNamespaceInteredId, genericParameterCount, this.CurrentTypeInternValue++); this.NamespaceTypeHashtable.Add((uint)typeName.UniqueKey, nsTypeStore1); return nsTypeStore1.InternedId; }
/// <summary> /// Visits the specified unit namespace reference. /// </summary> public void Visit(IUnitNamespaceReference unitNamespaceReference) { }
/// <summary> /// Allocates a type definition that is a member of a namespace definition. /// </summary> /// <param name="host">Provides a standard abstraction over the applications that host components that provide or consume objects from the metadata model.</param> /// <param name="containingUnitNamespace">The namespace that contains the referenced type.</param> /// <param name="name">The name of the referenced type.</param> /// <param name="genericParameterCount">The number of generic parameters. Zero if the type is not generic.</param> /// <param name="isEnum">True if the type is an enumeration (it extends System.Enum and is sealed). Corresponds to C# enum.</param> /// <param name="isValueType">True if the referenced type is a value type.</param> /// <param name="typeCode">A value indicating if the type is a primitive type or not.</param> public NamespaceTypeReference(IMetadataHost host, IUnitNamespaceReference containingUnitNamespace, IName name, ushort genericParameterCount, bool isEnum, bool isValueType, PrimitiveTypeCode typeCode) : base(host, isEnum, isValueType) { Contract.Requires(host != null); Contract.Requires(containingUnitNamespace != null); Contract.Requires(name != null); this.containingUnitNamespace = containingUnitNamespace; this.name = name; this.genericParameterCount = genericParameterCount; this.typeCode = typeCode; }
/// <summary> /// Traverses the specified unit namespace reference. /// </summary> public void Traverse(IUnitNamespaceReference unitNamespaceReference) { Contract.Requires(unitNamespaceReference != null); unitNamespaceReference.DispatchAsReference(this.dispatchingVisitor); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Visits the specified unit namespace reference. /// </summary> /// <param name="unitNamespaceReference">The unit namespace reference.</param> public virtual void Visit(IUnitNamespaceReference unitNamespaceReference) { unitNamespaceReference.Dispatch(this); }
public override void Visit(IUnitNamespaceReference unitNamespaceReference) { if(Process(unitNamespaceReference)){visitor.Visit(unitNamespaceReference);} base.Visit(unitNamespaceReference); }
/// <summary> /// Visits the specified unit namespace reference. /// </summary> /// <param name="unitNamespaceReference">The unit namespace reference.</param> public virtual void Visit(IUnitNamespaceReference unitNamespaceReference) //^ ensures this.path.Count == old(this.path.Count); { unitNamespaceReference.Dispatch(this); }
private static void WriteNamespaceAndSeparator(IUnitNamespaceReference ns, TextWriter writer) { Contract.Requires(ns != null); Contract.Requires(writer != null); INestedUnitNamespaceReference nested = ns as INestedUnitNamespaceReference; if (nested == null) return; // top-level Contract.Assume(nested.ContainingUnitNamespace != null, "lack of CCI2 contracts"); WriteNamespaceAndSeparator(nested.ContainingUnitNamespace, writer); writer.Write(nested.Name.Value); writer.Write("."); }
private void AppendMangledName(StringBuilder sb, IUnitNamespaceReference unitNamespace) { Contract.Requires(sb != null); Contract.Requires(unitNamespace != null); var nestedNamespace = unitNamespace as INestedUnitNamespaceReference; if (nestedNamespace == null) return; this.AppendMangledName(sb, nestedNamespace.ContainingUnitNamespace); sb.Append('_'); this.AppendSanitizedName(sb, nestedNamespace.Name.Value); }
public bool TryGetNamespaceReference(CSharpNamespace semanticNamespace, IAssemblyReference cciAssembly, out IUnitNamespaceReference cciNamespace) { Contract.Ensures(!Contract.Result <bool>() || (Contract.ValueAtReturn(out cciNamespace) != null)); cciNamespace = null; #region Check input if (semanticNamespace == null || cciAssembly == null) { return(false); } #endregion #region If root try { if (semanticNamespace.IsRoot) { cciNamespace = new Microsoft.Cci.MutableCodeModel.RootUnitNamespaceReference() { Unit = cciAssembly }; goto ReturnTrue; } } catch (InvalidOperationException e) { //For some reason, an InvalidOperationException may get thrown. if (e.Message.Contains(ContractsPackageAccessor.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate)) { goto ReturnFalse; } else { throw e; } } #endregion #region If nested if (semanticNamespace.ContainingNamespace != null) { IUnitNamespaceReference parentNs; if (!TryGetNamespaceReference(semanticNamespace.ContainingNamespace, cciAssembly, out parentNs)) { goto ReturnFalse; } if (semanticNamespace.Name == null) { goto ReturnFalse; } cciNamespace = new Microsoft.Cci.Immutable.NestedUnitNamespaceReference(parentNs, Host.NameTable.GetNameFor(semanticNamespace.Name.Text)); goto ReturnTrue; } #endregion Contract.Assert(cciNamespace == null); goto ReturnFalse; #region ReturnTrue: ReturnTrue: return(true); #endregion #region ReturnFalse: ReturnFalse: return(false); #endregion }
/// <summary> /// Visits the specified unit namespace reference. /// </summary> public virtual void Visit(IUnitNamespaceReference unitNamespaceReference) { Contract.Requires(unitNamespaceReference != null); }
/// <summary> /// Rewrites the specified reference to a unit namespace. /// </summary> public virtual IUnitNamespaceReference Rewrite(IUnitNamespaceReference unitNamespaceReference) { return unitNamespaceReference; }
void ModuleQualifiedUnitNamespace(IUnitNamespaceReference unitNamespace, out bool wasRoot) { INestedUnitNamespaceReference nestedUnitNamespace = unitNamespace as INestedUnitNamespaceReference; if (nestedUnitNamespace != null) { this.ModuleQualifiedUnitNamespace(nestedUnitNamespace.ContainingUnitNamespace, out wasRoot); if (!wasRoot) { this.ILDasmPaper.Symbol("."); } this.ILDasmPaper.Identifier(nestedUnitNamespace.Name.Value); wasRoot = false; } else { IModuleReference module = (IModuleReference)unitNamespace.Unit; if (module.ContainingAssembly != null) module = module.ContainingAssembly; if (!module.Equals(this.CurrentModule)) this.ModuleAsReference(module); wasRoot = true; } }
public override void Visit(IUnitNamespaceReference unitNamespaceReference) { allElements.Add(new InvokInfo(Traverser, "IUnitNamespaceReference", unitNamespaceReference)); }
public override void Visit(IUnitNamespaceReference unitNamespaceReference) { unitNamespaceReference.ResolvedUnitNamespace.Dispatch(this); }
public override void TraverseChildren(IUnitNamespaceReference unitNamespaceReference) { MethodEnter(unitNamespaceReference); base.TraverseChildren(unitNamespaceReference); MethodExit(); }
/// <summary> /// Visits the specified unit namespace reference. /// </summary> public virtual void Visit(IUnitNamespaceReference unitNamespaceReference) { //IUnitNamespaceReference is a base interface that should never be implemented directly. //Get unitNamespaceReference to call the most type specific visitor. unitNamespaceReference.Dispatch(this); }
/// <summary> /// Traverses the specified unit namespace reference. /// </summary> public virtual void TraverseChildren(IUnitNamespaceReference unitNamespaceReference) { Contract.Requires(unitNamespaceReference != null); this.Traverse(unitNamespaceReference.Unit); }
/// <summary> /// Traverses the specified unit namespace reference. /// </summary> public virtual void TraverseChildren(IUnitNamespaceReference unitNamespaceReference) { this.Traverse(unitNamespaceReference.Unit); }
/// <summary> /// Allocates a reference to a nested unit namespace. /// </summary> /// <param name="containingUnitNamespace">A reference to the unit namespace that contains the referenced nested unit namespace.</param> /// <param name="name">The name of the referenced nested unit namespace.</param> public NestedUnitNamespaceReference(IUnitNamespaceReference containingUnitNamespace, IName name) { this.containingUnitNamespace = containingUnitNamespace; this.name = name; }
public static string DocId(this IUnitNamespaceReference ns) { return("N:" + TypeHelper.GetNamespaceName(ns, NameFormattingOptions.None)); }
public override void TraverseChildren(IUnitNamespaceReference unitNamespaceReference) { base.TraverseChildren(unitNamespaceReference); }
private void AddUpwardNamespace(IUnitNamespaceReference iUnitNamespaceReference) { this.thingsToKeep.Add(iUnitNamespaceReference); var nested = iUnitNamespaceReference as INestedUnitNamespaceReference; if (nested != null) this.AddUpwardNamespace(nested.ContainingUnitNamespace); }
uint GetUnitNamespaceInternId(IUnitNamespaceReference unitNamespaceReference) { Contract.Requires(unitNamespaceReference != null); INestedUnitNamespaceReference/*?*/ nestedUnitNamespaceReference = unitNamespaceReference as INestedUnitNamespaceReference; if (nestedUnitNamespaceReference != null) { return this.GetNestedNamespaceInternId(nestedUnitNamespaceReference); } return this.GetUnitRootNamespaceInternId(unitNamespaceReference.Unit); }
public uint GetNamespaceTypeReferenceInternedKey(IUnitNamespaceReference containingUnitNamespace, IName typeName, uint genericParameterCount) { return 0; }
uint IInternFactory.GetNamespaceTypeReferenceInternedKey(IUnitNamespaceReference containingUnitNamespace, IName typeName, uint genericParameterCount) { lock (GlobalLock.LockingObject) { return this.GetNamespaceTypeReferenceInternId(containingUnitNamespace, typeName, genericParameterCount); } }
public uint GetNamespaceTypeReferenceInternedKey(IUnitNamespaceReference containingUnitNamespace, IName typeName, uint genericParameterCount) { return(m_factory.GetNamespaceTypeReferenceInternedKey(containingUnitNamespace, typeName, genericParameterCount)); }
public bool TryGetNamespaceReference(INamespaceSymbol semanticNamespace, IAssemblyReference cciAssembly, out IUnitNamespaceReference cciNamespace) { Contract.Ensures(!Contract.Result<bool>() || (Contract.ValueAtReturn(out cciNamespace) != null)); cciNamespace = null; #region Check input if (semanticNamespace == null || cciAssembly == null) { return false; } #endregion #region If root try { if (semanticNamespace.IsGlobalNamespace) { cciNamespace = new Microsoft.Cci.MutableCodeModel.RootUnitNamespaceReference() { Unit = cciAssembly }; goto ReturnTrue; } } catch (InvalidOperationException e) { //For some reason, an InvalidOperationException may get thrown. if (e.Message.Contains(ContractsPackageAccessor.InvalidOperationExceptionMessage_TheSnapshotIsOutOfDate)) goto ReturnFalse; else throw e; } #endregion #region If nested if (semanticNamespace.ContainingNamespace != null) { IUnitNamespaceReference parentNs; if (!TryGetNamespaceReference(semanticNamespace.ContainingNamespace, cciAssembly, out parentNs)) goto ReturnFalse; if (semanticNamespace.Name == null) goto ReturnFalse; cciNamespace = new Microsoft.Cci.Immutable.NestedUnitNamespaceReference(parentNs, Host.NameTable.GetNameFor(semanticNamespace.Name)); goto ReturnTrue; } #endregion Contract.Assert(cciNamespace == null); goto ReturnFalse; #region ReturnTrue: ReturnTrue: return true; #endregion #region ReturnFalse: ReturnFalse: return false; #endregion }
/// <summary> /// Traverses the specified unit namespace reference. /// </summary> public void Traverse(IUnitNamespaceReference unitNamespaceReference) { unitNamespaceReference.DispatchAsReference(this.dispatchingVisitor); }