private void WriteConstructorInvocation(ObjectCreationExpression node)
{
if (node.Constructor.DeclaringType is TypeSpecification)
{
GenericInstanceType generic = node.Constructor.DeclaringType as GenericInstanceType;
if (generic != null)
{
if (SupportsSpecialNullable && (generic.GetFriendlyFullName(Language).IndexOf("System.Nullable<") == 0) &&
generic.GenericArguments[0].IsValueType)
{
TypeReference toWrite = generic.GenericArguments[0];
if (generic.PostionToArgument.ContainsKey(0))
{
toWrite = generic.PostionToArgument[0];
}
WriteReferenceAndNamespaceIfInCollision(toWrite);
WriteToken("?");
return;
}
}
}
if (node.Constructor.DeclaringType.Namespace == "System")
{
WriteReferenceAndNamespaceIfInCollision(node.Constructor.DeclaringType);
return;
}
if (node.Constructor.DeclaringType.DeclaringType != null)
{
TypeReference declaringType = node.Constructor.DeclaringType.DeclaringType;
if (node.Constructor.DeclaringType.IsGenericInstance)
{
GenericInstanceType referenceGeneric = node.Constructor.DeclaringType as GenericInstanceType;
if (declaringType.HasGenericParameters)
{
/// Transfer the parameters from reference up to the declaring type.
/// Bare in mind, that the declaring type might have less generic parameters.
/// Transfer just the first X that match.
/// This is needed, because VB and C# don't allow other language syntax
GenericInstanceType declaringTypeInstance = new GenericInstanceType(declaringType);
Collection<TypeReference> nestedTypeBackup = new Collection<TypeReference>(referenceGeneric.GenericArguments);
Collection<TypeReference> declaringBackup = new Collection<TypeReference>(declaringTypeInstance.GenericArguments);
int parametersToMoveUp = declaringType.GenericParameters.Count;
for (int i = 0; i < parametersToMoveUp; i++)
{
/// check if it moves the parameters forward or not
declaringTypeInstance.AddGenericArgument(referenceGeneric.GenericArguments[i]);
declaringTypeInstance.GenericArguments.Add(referenceGeneric.GenericArguments[i]);
}
WriteReferenceAndNamespaceIfInCollision(declaringTypeInstance);
Write(".");
if (referenceGeneric.GenericArguments.Count - parametersToMoveUp > 0)
{
WriteConstructorNameAndGenericArguments(node, true, parametersToMoveUp);
}
else
{
WriteConstructorNameAndGenericArguments(node, false);
}
referenceGeneric.GenericArguments.Clear();
referenceGeneric.GenericArguments.AddRange(nestedTypeBackup);
declaringTypeInstance.GenericArguments.Clear();
declaringTypeInstance.GenericArguments.AddRange(declaringBackup);
return;
}
}
WriteReferenceAndNamespaceIfInCollision(declaringType);
Write(".");
WriteConstructorNameAndGenericArguments(node);
}
else
{
bool isTypeNameInCollision = IsTypeNameInCollision(node.Constructor.DeclaringType.Name);
WriteNamespace(node.Constructor.DeclaringType.GetElementType(), isTypeNameInCollision);
WriteConstructorNameAndGenericArguments(node);
}
}
private void WriteReference(TypeReference reference)
{
if (reference.DeclaringType != null)
{
TypeReference declaringType = reference.DeclaringType;
if (reference.IsGenericInstance)
{
GenericInstanceType referenceGeneric = reference as GenericInstanceType;
if (declaringType.HasGenericParameters)
{
/// Transfer the parameters from reference up to the declaring type.
/// Bare in mind, that the declaring type might have less generic parameters.
/// Transfer just the first X that match.
/// This is needed, because VB and C# don't allow other language syntax
GenericInstanceType declaringTypeInstance = new GenericInstanceType(declaringType);
Collection<TypeReference> nestedTypeBackup = new Collection<TypeReference>(referenceGeneric.GenericArguments);
Collection<TypeReference> declaringBackup = new Collection<TypeReference>(declaringTypeInstance.GenericArguments);
int parametersToMoveUp = declaringType.GenericParameters.Count;
for (int i = 0; i < parametersToMoveUp; i++)
{
/// check if it moves the parameters forward or not
declaringTypeInstance.AddGenericArgument(referenceGeneric.GenericArguments[i]);
declaringTypeInstance.GenericArguments.Add(referenceGeneric.GenericArguments[i]);
}
WriteReference(declaringTypeInstance);
Write(".");
if (referenceGeneric.GenericArguments.Count - parametersToMoveUp > 0)
{
WriteTypeSpecification(referenceGeneric, parametersToMoveUp);
}
else
{
string typeName = GetTypeName(reference);
WriteReference(typeName, reference);
}
referenceGeneric.GenericArguments.Clear();
referenceGeneric.GenericArguments.AddRange(nestedTypeBackup);
declaringTypeInstance.GenericArguments.Clear();
declaringTypeInstance.GenericArguments.AddRange(declaringBackup);
return;
}
else
{
WriteReference(declaringType);
Write(".");
}
}
else
{
WriteReference(declaringType);
Write(".");
}
}
if (reference is TypeSpecification)
{
WriteTypeSpecification(reference as TypeSpecification);
return;
}
string typeString;
if (reference.Namespace != "System")
{
typeString = GetTypeName(reference);
}
else
{
typeString = ToTypeString(reference);
if (reference.Scope.Name != "mscorlib" && reference.Scope.Name != "CommonLanguageRuntimeLibrary")
{
typeString = Utilities.EscapeTypeName(typeString, this.Language);
}
}
if (reference.HasGenericParameters || (!Language.IsEscapedWord(typeString) && !Language.IsValidIdentifier(typeString)))
{
if (reference is TypeDefinition && reference.HasGenericParameters)
{
typeString = GetTypeName(reference);
int genericParametersStartIndex = 0;
if (reference.DeclaringType != null && reference.DeclaringType.HasGenericParameters)
{
genericParametersStartIndex = reference.DeclaringType.GenericParameters.Count;
}
if (genericParametersStartIndex < reference.GenericParameters.Count)
{
typeString += GenericLeftBracket;
for (int i = genericParametersStartIndex; i < reference.GenericParameters.Count; i++)
{
if (i > genericParametersStartIndex)
{
typeString += ", ";
}
if (!Language.IsValidIdentifier(reference.GenericParameters[i].Name))
{
typeString += Language.ReplaceInvalidCharactersInIdentifier(reference.GenericParameters[i].Name);
}
else
{
typeString += reference.GenericParameters[i].Name;
}
}
typeString += GenericRightBracket;
// check if the type name is actually correct
}
}
else
{
typeString = GetTypeName(reference);
//typeString = Language.ReplaceInvalidCharactersInIdentifier(typeString);
}
}
if (reference.IsGenericParameter)
{
WriteReference(typeString, null);
}
else
{
WriteReference(typeString, reference);
}
}
private string HandleNestedGenericTypes(TypeReference parameterType)
{
/// Transfer the parameters from reference up to the declaring type.
/// Bare in mind, that the declaring type might have less generic parameters.
/// Transfer just the first X that match.
/// This is needed, because VB and C# don't allow other language syntax
StringBuilder result = new StringBuilder();
TypeReference declaringType = parameterType.DeclaringType;
GenericInstanceType referenceGeneric = parameterType as GenericInstanceType;
GenericInstanceType declaringTypeInstance = new GenericInstanceType(declaringType);
Collection<TypeReference> nestedTypeBackup = new Collection<TypeReference>(referenceGeneric.GenericArguments);
Collection<TypeReference> declaringBackup = new Collection<TypeReference>(declaringTypeInstance.GenericArguments);
int parametersToMoveUp = declaringType.GenericParameters.Count;
for (int i = 0; i < parametersToMoveUp; i++)
{
declaringTypeInstance.AddGenericArgument(referenceGeneric.GenericArguments[i]);
declaringTypeInstance.GenericArguments.Add(referenceGeneric.GenericArguments[i]);
}
result.Append(GetParameterTypeRepresentation(declaringTypeInstance));
result.Append('.');
if (referenceGeneric.GenericArguments.Count - parametersToMoveUp > 0)
{
result.Append(AppendGenericArguments(referenceGeneric, parametersToMoveUp));
}
else
{
string ptName = GenericHelper.GetNonGenericName(parameterType.Name);
result.Append(ptName);
}
referenceGeneric.GenericArguments.Clear();
referenceGeneric.GenericArguments.AddRange(nestedTypeBackup);
declaringTypeInstance.GenericArguments.Clear();
declaringTypeInstance.GenericArguments.AddRange(declaringBackup);
return result.ToString();
}