public Types.Type GetGenericTypeParameter(string name)
{
return(GenericTypeParameters
.Select((parameter, index) => new { parameter, index })
.Where(pair => pair.parameter.Name == name)
.Select(pair => TypeArguments[pair.index])
.FirstOrDefault());
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ReturnType != null ? ReturnType.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (NativeName != null ? NativeName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Parameters.GetHashCode();
hashCode = (hashCode * 397) ^ Categories.GetHashCode();
hashCode = (hashCode * 397) ^ GenericTypeParameters.GetHashCode();
hashCode = (hashCode * 397) ^ (Attributes != null ? Attributes.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Doc != null ? Doc.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ExtensionName != null ? ExtensionName.GetHashCode() : 0);
return(hashCode);
}
}
public bool Equals(Function other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(string.Equals(Name, other.Name) &&
Parameters.Select(x => x.Type.ToString()).SequenceEqual(other.Parameters.Select(x => x.Type.ToString())) &&
GenericTypeParameters.SequenceEqual(other.GenericTypeParameters));
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked
{
// ReSharper disable NonReadonlyMemberInGetHashCode
var hashCode = (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ReturnType != null ? ReturnType.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (NativeName != null ? NativeName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Parameters.GetHashCode();
hashCode = (hashCode * 397) ^ Categories.GetHashCode();
hashCode = (hashCode * 397) ^ GenericTypeParameters.GetHashCode();
hashCode = (hashCode * 397) ^ (Attributes != null ? Attributes.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Doc != null ? Doc.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ExtensionName != null ? ExtensionName.GetHashCode() : 0);
// ReSharper restore NonReadonlyMemberInGetHashCode
return(hashCode);
}
}
public override string WriteTypeScript(CodeConversionOptions options, Context context)
{
context = context.Clone();
context.GenericTypeParameters = GenericTypeParameters;
// keywords
return("export ".If(options.Export) + "interface "
// name
+ Name.TransformIf(options.RemoveInterfacePrefix, StringUtilities.RemoveInterfacePrefix)
// generic type parameters
+ ("<" + GenericTypeParameters.ToCommaSepratedList() + ">").If(GenericTypeParameters.Any())
// base types
+ (" extends " + BaseTypes.WriteTypeScript(options, context).ToCommaSepratedList()).If(BaseTypes.Any())
// body
+ " {" + NewLine
// fields
+ Fields.WriteTypeScript(options, context).Indent(options.UseTabs, options.TabSize).LineByLine() + NewLine
+ "}");
}
private void GetDeclarationString(StringBuilder sb, bool? @unsafe)
{
if (Parameters.Any(p => p.Type.IsPointer) || ReturnType.IsPointer || @unsafe.HasValue && @unsafe.Value)
{
sb.Append("unsafe ");
}
sb.Append(ReturnType);
sb.Append(" ");
sb.Append(Name);
if (GenericTypeParameters.Count != 0)
{
sb.Append("<");
var genericParameterNames = GenericTypeParameters.Select(p => p.Name);
var genericParameterList = string.Join(", ", genericParameterNames);
sb.Append(genericParameterList);
sb.Append(">");
}
}
public override string ToString()
{
if (IsPrimitive)
{
return(CSharpName);
}
string typename = "";
if (!IsEmpty)
{
typename = CSharpName;
}
if (typename == "")
{
typename = "object";
}
if (IsArray)
{
typename = $"{ElementType?.ToString() ?? "object"}[]";
}
else if (IsGenericType && GenericTypeParameters.Any())
{
typename = Name.Split("`")[0] + "<";
foreach (LookupType t in GenericTypeParameters)
{
typename += t.ToString() + (GenericTypeParameters[GenericTypeParameters.Count() - 1] != t ? ", " : "");
}
typename += ">";
}
else
{
typename = CSharpName;
}
return(typename);
}
public override string ToString()
{
if (IsPrimitive)
{
return(CSharpName);
}
StringBuilder typename = new StringBuilder();
if (!IsEmpty)
{
typename.Append(CSharpName);
}
if (IsArray)
{
typename.Clear();
typename.Append($"{ElementType?.ToString() ?? "object"}[]");
}
else if (IsGenericType && GenericTypeParameters.Any())
{
typename.Clear();
typename.Append(Name.Split("`")[0] + "<");
foreach (UnitorType t in GenericTypeParameters)
{
typename.Append(t.ToString() + (GenericTypeParameters[GenericTypeParameters.Count() - 1] != t ? ", " : ""));
}
typename.Append('>');
}
if (typename.Length == 0)
{
typename.Append("object");
}
return(typename.ToString());
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public string MakeGenericName(string openBracket, string closeBracket, string commaSeparator)
{
if (!IsGenericType)
{
return(this.Name);
}
if (IsGenericTypeDefinition)
{
return(
this.Name +
openBracket +
string.Join(commaSeparator, GenericTypeParameters.Select(t => t.Name)) +
closeBracket);
}
else
{
return(
this.Name +
openBracket +
string.Join(commaSeparator, GenericTypeArguments.Select(t => t.MakeGenericName(openBracket, closeBracket, commaSeparator))) +
closeBracket);
}
}
public string WriteTypeScript(CodeConversionOptions options)
=> "export ".If(options.Export) + "interface " + Name.RemoveInterfacePrefix() + ("<" + GenericTypeParameters.ToCommaSepratedList() + ">").If(GenericTypeParameters.Any()) + (" extends " + BaseTypes.Select(e => e.WriteTypeScript()).ToCommaSepratedList()).If(BaseTypes.Any()) + " {" + NewLine
+ Fields.Select(f => f.WriteTypeScript()).Indent(options.UseTabs, options.TabSize).LineByLine() + NewLine
+ "}";
public void AddGenericTypeParameter(string pHint)
{
var t = CreateGenericParameter(pHint);
GenericTypeParameters.Add(t);
}
public override void LeaveMethod(Boo.Lang.Compiler.Ast.Method node)
{
var method = (IMethod) node.Entity;
var designator=new StringBuilder();
designator.Append("M:");
var nodeName=node.FullName;
var posGenericParams=nodeName.IndexOf('[');
if (posGenericParams >= 0)
nodeName=nodeName.Substring(0, posGenericParams);
designator.Append(nodeName);
if (GenericsServices.IsGenericMethod(node.Entity))
{
designator.Append("``"); // TODO: I will not deal with nested classes here. ` for the class parameters, `` for method parameters. That's it for now.
designator.Append(GenericsServices
.GetMethodGenerity(method)
.ToString());
}
if (node.Parameters.Count > 0)
{
designator.Append("(");
int i=0;
var genericParams = new GenericTypeParameters(method);
foreach (Ast.ParameterDeclaration p in node.Parameters)
{
if (i > 0) designator.Append(",");
designator.Append(CilTypeName(genericParams, p.Type));
i+=1;
}
designator.Append(")");
}
this.ProcessDocumentation(designator.ToString(), node);
base.LeaveMethod(node);
}
static string CilTypeName(GenericTypeParameters generics, IType typeEntity)
{
// TODO this method should also complete the qualifiers.
if (GenericsServices.IsGenericParameter(typeEntity))
{
return generics.ToString(typeEntity.Name);
}
else
{
var result = ToTypeName( typeEntity.FullName );
var numberOfGenericArguments=NumberOfGenericArguments(typeEntity);
if (numberOfGenericArguments > 0)
{
result+="{";
int iGenericArg=0;
foreach(var genericArgument in typeEntity.ConstructedInfo.GenericArguments)
{
if (iGenericArg > 0)
result+=",";
result+=CilTypeName(generics, genericArgument);
iGenericArg+=1;
}
result+="}";
}
return result;
}
}
/// <summary>
/// Returns the CIL designator of a particular type.
/// </summary>
/// <param name="tref">The reference to a type. Entity must have been resolved.</param>
/// <returns></returns>
static string CilTypeName(GenericTypeParameters generics, Ast.TypeReference typeRef)
{
return CilTypeName(generics, (IType)typeRef.Entity);
}
