public static void Load(this IMethodModel @this, ICodeTextWriter writer, SourceBuilder builder, IMethodSymbol method, ScopeInfo scope, IEnumerable <IMemberInfo> references)
{
var methodScope = new ScopeInfo(scope);
if (method.IsGenericMethod)
{
methodScope.CreateAliases(method.TypeArguments);
}
(bool isAsync, bool methodReturnsValue) = SemanticFacts.IsAsyncAndGetReturnType(writer.Compilation, method);
bool canUseAsync = true;
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteIdentifier(builder2, method);
if (method.IsGenericMethod)
{
builder2.Append('<');
writer.WriteTypeArgumentsCall(builder2, method.TypeArguments, methodScope);
builder2.Append('>');
}
@this.Name = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteTypeReference(builder2, method.ReturnType, methodScope);
@this.ReturnType = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteParameterDefinition(builder2, methodScope, method.Parameters);
@this.ArgumentsDefinition = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteCallParameters(builder2, method.Parameters);
@this.CallArguments = builder2.ToString();
}
@this.IsAsync = isAsync && canUseAsync;
@this.ReturnExpected = (isAsync && methodReturnsValue == false) ? canUseAsync == false : methodReturnsValue;
foreach (IMemberInfo reference in references)
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
if (isAsync && canUseAsync)
{
writer.WriteMethodCall(builder2, reference, method, methodScope, false, false, false);
}
else
{
writer.WriteMethodCall(builder2, reference, method, methodScope, false, SemanticFacts.IsNullable(writer.Compilation, method.ReturnType), reference.PreferCoalesce);
}
@this.Expressions.Add(builder2.ToString());
}
}
public string GetMethodUniqueName(IMethodModel method)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (Methods.Count(x => x.OriginalName == method.OriginalName) == 1)
{
return(method.OriginalName);
}
var parameters = new List <string>();
var hasEquallyNamedOverload = Methods.Any(x => x != method && x.Parameters.Count == method.Parameters.Count && x.Parameters.Select(p => p.Name.ToPascalCase()).SequenceEqual(method.Parameters.Select(p => p.Name.ToPascalCase())));
var hasEquallyTypedOverload = Methods.Any(x => x != method && x.Parameters.Count == method.Parameters.Count && x.Parameters.Select(p => p.Type.ToPascalCase()).SequenceEqual(method.Parameters.Select(p => p.Type.ToPascalCase())));
if (hasEquallyTypedOverload && (method.Node?.TypeParameterList?.Parameters.Count ?? 0) > 0)
{
parameters.AddRange(method.Node.TypeParameterList.Parameters.Select(x => x.Identifier.ValueText));
}
for (int i = 0; i < method.Parameters.Count; i++)
{
var hasEquallyNamedParameter = Methods.Any(x => x != method && x.Parameters.Count == method.Parameters.Count && string.Equals(x.Parameters[i].Name, method.Parameters[i].Name, StringComparison.OrdinalIgnoreCase));
if (hasEquallyNamedOverload && hasEquallyNamedParameter)
{
parameters.Add(method.Parameters[i].TypeInfo.Type.ToIdentifierName().ToPascalCase());
}
else
{
parameters.Add(method.Parameters[i].Name.ToPascalCase());
}
}
var baseName = method.OriginalName;
if (method.Node?.ExplicitInterfaceSpecifier != null)
{
baseName += "For" + Generate.CleanName(method.Node.ExplicitInterfaceSpecifier.Name.ToString());
}
return(string.Format(CultureInfo.InvariantCulture, "{0}With{1}", baseName, parameters.Any() ? parameters.Select(x => x.ToPascalCase()).Aggregate((x, y) => x + "And" + y) : "NoParameters"));
}
public CodeFunction2(CodeModelContext context, IMethodModel methodModel)
: base(context, methodModel)
{
}
public override void TryAddMethodModel(IMethodModel methodModel, ByteArray methodId)
{
lock (this.LockMethods)
base.TryAddMethodModel(methodModel, methodId);
}
public override void AddAssemblyBinding(Guid assemblyGuid, IMethodModel methodModel)
{
lock (this.LockMethods)
base.AddAssemblyBinding(assemblyGuid, methodModel);
}
public override bool TryGetMethodModelForName(string name, out IMethodModel result)
{
lock (this.LockMethods)
return(base.TryGetMethodModelForName(name, out result));
}
public override bool TryGetMethodModelForHash(ByteArray hash, out IMethodModel result)
{
lock (this.LockMethods)
return(base.TryGetMethodModelForHash(hash, out result));
}
