/// <summary> /// Adds the type definition to this project content. /// Replaces existing type definitions with the same name. /// </summary> public void UpdateType(ITypeDefinition typeDefinition) { if (typeDefinition == null) { throw new ArgumentNullException("typeDefinition"); } var key = new FullNameAndTypeParameterCount(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameterCount); bool isNew = !_typeDicts[0].ContainsKey(key); foreach (var dict in _typeDicts) { dict[key] = typeDefinition; } if (isNew) { foreach (var dict in _namespaceDicts) { NamespaceEntry ns; if (dict.TryGetValue(typeDefinition.Namespace, out ns)) { ++ns.ClassCount; } else { dict.Add(typeDefinition.Namespace, new NamespaceEntry(typeDefinition.Namespace) { ClassCount = 1 }); } } } }
/// <inheritdoc/> public ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer) { if (nameSpace == null) { throw new ArgumentNullException("nameSpace"); } if (name == null) { throw new ArgumentNullException("name"); } if (nameComparer == null) { throw new ArgumentNullException("nameComparer"); } var key = new FullNameAndTypeParameterCount(nameSpace, name, typeParameterCount); ITypeDefinition result; if (GetTypeDictionary(nameComparer).TryGetValue(key, out result)) { return(result); } else { return(null); } }
public IUnresolvedTypeDefinition GetTypeDefinition(string ns, string name, int typeParameterCount) { var key = new FullNameAndTypeParameterCount(ns ?? string.Empty, name, typeParameterCount); IUnresolvedTypeDefinition td; if (typeDefinitions.TryGetValue(key, out td)) { return(td); } else { return(null); } }
ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount) { var key = new FullNameAndTypeParameterCount(ns.FullName, name, typeParameterCount); IUnresolvedTypeDefinition unresolvedTypeDef; if (assembly.unresolvedTypeDict.TryGetValue(key, out unresolvedTypeDef)) { return(assembly.GetTypeDefinition(unresolvedTypeDef)); } else { return(null); } }
/// <summary> /// Adds a type forwarder. /// This adds both an assembly attribute and an internal forwarder entry, which will be used /// by the resolved assembly to provide the forwarded types. /// </summary> /// <param name="typeName">The name of the type.</param> /// <param name="referencedType">The reference used to look up the type in the target assembly.</param> public void AddTypeForwarder(FullNameAndTypeParameterCount typeName, ITypeReference referencedType) { if (referencedType == null) { throw new ArgumentNullException("referencedType"); } FreezableHelper.ThrowIfFrozen(this); var attribute = new DefaultUnresolvedAttribute(typeForwardedToAttributeTypeRef, new[] { KnownTypeReference.Type }); attribute.PositionalArguments.Add(new TypeOfConstantValue(referencedType)); assemblyAttributes.Add(attribute); typeForwarders[typeName] = referencedType; }
/// <summary> /// Adds a new top-level type definition to this assembly. /// </summary> /// <remarks>DefaultUnresolvedAssembly does not support partial classes. /// Adding more than one part of a type will cause an ArgumentException.</remarks> public void AddTypeDefinition(IUnresolvedTypeDefinition typeDefinition) { if (typeDefinition == null) { throw new ArgumentNullException("typeDefinition"); } if (typeDefinition.DeclaringTypeDefinition != null) { throw new ArgumentException("Cannot add nested types."); } FreezableHelper.ThrowIfFrozen(this); var key = new FullNameAndTypeParameterCount(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameters.Count); typeDefinitions.Add(key, typeDefinition); }
public ITypeDefinition GetTypeDefinition(string ns, string name, int typeParameterCount) { var key = new FullNameAndTypeParameterCount(ns ?? string.Empty, name, typeParameterCount); IUnresolvedTypeDefinition td; ITypeReference typeRef; if (unresolvedAssembly.typeDefinitions.TryGetValue(key, out td)) { return(GetTypeDefinition(td)); } else if (unresolvedAssembly.typeForwarders.TryGetValue(key, out typeRef)) { return(typeRef.Resolve(compilation.TypeResolveContext).GetDefinition()); } else { return(null); } }
/// <summary> /// Removes a type definition from this project content. /// </summary> public bool RemoveType(ITypeDefinition typeDefinition) { if (typeDefinition == null) { throw new ArgumentNullException("typeDefinition"); } var key = new FullNameAndTypeParameterCount(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameterCount); bool wasRemoved = false; foreach (var dict in _typeDicts) { ITypeDefinition defInDict; if (dict.TryGetValue(key, out defInDict)) { if (defInDict == typeDefinition) { if (dict.Comparer == FullNameAndTypeParameterCountComparer.Ordinal) { // Set wasRemoved flag only on removal in the ordinal comparison. // This keeps the ClassCount consistent when there are name clashes. wasRemoved = true; } dict.Remove(key); } } } if (wasRemoved) { foreach (var dict in _namespaceDicts) { NamespaceEntry ns; if (dict.TryGetValue(typeDefinition.Namespace, out ns)) { ns.ClassCount--; RemoveNamespaceIfPossible(dict, ns); } } } return(wasRemoved); }
/// <summary> /// Removes a type definition from this project content. /// </summary> public void RemoveType(ITypeDefinition typeDefinition) { if (typeDefinition == null) { throw new ArgumentNullException("typeDefinition"); } var key = new FullNameAndTypeParameterCount(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameterCount); bool wasRemoved = false; foreach (var dict in _typeDicts) { ITypeDefinition defInDict; if (dict.TryGetValue(key, out defInDict)) { if (defInDict == typeDefinition) { wasRemoved = true; dict.Remove(key); } } } if (wasRemoved) { foreach (var dict in _namespaceDicts) { NamespaceEntry ns; if (dict.TryGetValue(typeDefinition.Namespace, out ns)) { if (--ns.ClassCount == 0) { dict.Remove(typeDefinition.Namespace); } } } } }
/// <summary> /// Adds the type definition to this project content. /// Replaces existing type definitions with the same name. /// </summary> public void UpdateType(ITypeDefinition typeDefinition) { if (typeDefinition == null) { throw new ArgumentNullException("typeDefinition"); } var key = new FullNameAndTypeParameterCount(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameterCount); // Set isNew on addition in the ordinal comparison. // This keeps the ClassCount consistent when there are name clashes. bool isNew = !_typeDicts[0].ContainsKey(key); foreach (var dict in _typeDicts) { dict[key] = typeDefinition; } if (isNew) { foreach (var dict in _namespaceDicts) { NamespaceEntry ns = GetOrCreateNamespaceEntry(dict, typeDefinition.Namespace); ++ns.ClassCount; } } }