public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var matchedRange = rangePattern.Match(param);
if (matchedRange.Success)
{
var from = int.Parse(matchedRange.Groups["from"].Value);
var to = int.Parse(matchedRange.Groups["to"].Value);
var step = 1;
if (matchedRange.Groups["step"].Success)
{
step = Math.Max(int.Parse(matchedRange.Groups["step"].Value), 1);
if (from > to)
{
to = from;
}
}
for (int i = from; i <= to; i += step)
{
yield return(new Dictionary <string, string>()
{
["index"] = i.ToString(),
["from"] = from.ToString(),
["to"] = to.ToString(),
["step"] = step.ToString()
});
}
}
}
public static TypeInfo GetTypeInfo(string typeName, ICsharpMacroContext context)
{
var typeInfo = GetTypeInfo(typeName);
typeInfo.Symbol = FindMatchingSymbol(context, typeInfo);
return(typeInfo);
}
public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var typeInfo = TypeHelper.GetTypeInfo(param, context);
foreach (var member in typeInfo.SelectAllMembers <IMethodSymbol>().Where(x => x.MethodKind == MethodKind.Ordinary))
{
var(returnTypeShorty, returnTypeLong) = typeInfo.GetMemberType(member.ReturnType);
var attributes = new Dictionary <string, string>()
{
["name"] = member.Name,
["returnType"] = returnTypeShorty,
["returnTypeLong"] = returnTypeLong,
["signature"] = GetSignature(member, context),
["returnOperator"] = GetReturnOperator(returnTypeShorty),
["parameters"] = GetParametersString(member),
["genericParameters"] = GetGenericParametersString(member)
};
int parameterIndex = 1;
foreach (var parameter in member.Parameters)
{
var(paramTypeShort, paramTypeLong) = typeInfo.GetMemberType(parameter.Type);
attributes.Add($"paramName{parameterIndex}", parameter.Name);
attributes.Add($"paramType{parameterIndex}", paramTypeShort);
attributes.Add($"paramTypeLong{parameterIndex}", paramTypeLong);
parameterIndex++;
}
yield return(attributes);
}
}
public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var tupleMatches = tuplePattern.Matches(param);
if (tupleMatches.Count > 0)
{
return(tupleMatches.OfType <Match>().Select(m => GetAttributesForTuple(m.Groups[1].Value)));
}
return(GetAttributesForSingleValue(param));
}
public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var typeInfo = TypeHelper.GetTypeInfo(param, context);
var derived = SymbolFinder.FindDerivedClassesAsync(typeInfo.Symbol, context.Solution).GetAwaiter().GetResult();
foreach (var derivedType in derived)
{
yield return(new Dictionary <string, string>()
{
["name"] = derivedType.GetFullGenericName(),
["based"] = typeInfo.Symbol.Name
});
}
}
public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var typeInfo = TypeHelper.GetTypeInfo(param, context);
foreach (var member in typeInfo.SelectAllMembers <IPropertySymbol>())
{
var(typeNameShort, typeNameLong) = typeInfo.GetMemberType(member.Type);
yield return(new Dictionary <string, string>()
{
["name"] = member.Name,
["type"] = typeNameShort,
["typeLong"] = typeNameLong
});
}
}
public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var typeInfo = TypeHelper.GetTypeInfo(param, context);
var implementations = SymbolFinder.FindImplementationsAsync(typeInfo.Symbol, context.Solution).GetAwaiter().GetResult();
foreach (var implementation in implementations.OrderBy(x => x.Name).OfType <INamedTypeSymbol>())
{
var allInterfaces = TypeHelper.GetBaseTypesAndThis(implementation).SelectMany(x => x.Interfaces);
yield return(new Dictionary <string, string>()
{
["name"] = implementation.GetFullGenericName(),
["interface"] = TypeHelper.FindMatchingSymbol(allInterfaces, typeInfo)?.GetFullGenericName() ?? typeInfo.Name
});
}
}
private static string GetSignature(IMethodSymbol member, ICsharpMacroContext context)
{
string PresentSymbol(ISymbol typeSymbol)
{
return(typeSymbol.ToMinimalDisplayString(context.SemanticModel, context.MacroLocation.SourceSpan.Start));
}
var parameters = string.Join(", ", member.Parameters.Select(x => $"{PresentSymbol(x)}".Trim()));
if (member.IsGenericMethod)
{
var genericParameters = GetGenericParametersString(member);
return($"{PresentSymbol(member.ReturnType)} {member.Name}{genericParameters}({parameters})");
}
return($"{PresentSymbol(member.ReturnType)} {member.Name}({parameters})");
}
public IEnumerable <Dictionary <string, string> > ExecuteMacro(string param, ICsharpMacroContext context)
{
var typeInfo = TypeHelper.GetTypeInfo(param, context);
if (typeInfo.Symbol is { } symbol&& symbol.TypeKind == TypeKind.Enum)
{
foreach (var member in symbol.GetMembers())
{
if (member.Kind == SymbolKind.Field)
{
yield return(new Dictionary <string, string>()
{
["name"] = member.Name
});
}
}
}
}
private static List <INamedTypeSymbol> FindSymbolCandidates(ICsharpMacroContext context, TypeInfo typeInfo)
{
var namedCandidates = context.SemanticModel.Compilation.GetSymbolsWithName(typeInfo.Name)
.OfType <INamedTypeSymbol>()
.ToList();
if (namedCandidates.Count != 0)
{
return(namedCandidates);
}
var symbol = context.SemanticModel.Compilation.GetTypeByMetadataName(typeInfo.FullName);
if (symbol != null)
{
return(new List <INamedTypeSymbol>()
{
symbol
});
}
return(new List <INamedTypeSymbol>());
}
private static string TransformContent(ICsharpMacro macro, MacroDescriptor macroDescriptor, ICsharpMacroContext macroContext)
{
var sb = new StringBuilder();
foreach (var attributes in macro.ExecuteMacro(macroDescriptor.Param, macroContext))
{
var transformedItem = TransformedTemplate(macroDescriptor.Template, attributes);
sb.Append(transformedItem);
}
return(sb.ToString().Replace("//", ""));
}
private static INamedTypeSymbol FindMatchingSymbol(ICsharpMacroContext context, TypeInfo typeInfo)
{
var namedCandidates = FindSymbolCandidates(context, typeInfo);
return(FindMatchingSymbol(namedCandidates, typeInfo));
}
