public static MethodBase ToCSharpMethod(this IMethodSymbol methodSymbol, List <NamedTypeBase> types, SemanticModel model, NamedTypeBase parentType, LoggerProvider logprovider)
{
if (methodSymbol == null)
{
return(null);
}
INamedType drt = null;
//hack
if (methodSymbol.ReturnType.TypeKind != TypeKind.TypeParameter)
{
drt = types.FirstOrDefault(t => t == methodSymbol.ReturnType.ToCSharpNamedType(logprovider));
if (drt == null && !methodSymbol.ReturnsVoid)
{
logprovider.WriteToLog(string.Format("Cannot find type for {0} as the non-void declared return type of method {1}, creating empty type manually", methodSymbol.ReturnType.ToString(), methodSymbol.ToString()));
types.Add(methodSymbol.ReturnType.ToCSharpNamedType(logprovider));
}
}
List <IMethodParameter> parameters = new List <IMethodParameter>();
foreach (var paramSymbol in methodSymbol.Parameters)
{
parameters.Add(paramSymbol.ToCSharpMethodParameter(types, logprovider));
}
return(new CSharpMethod
{
IsAbstract = methodSymbol.IsAbstract,
IsOverride = methodSymbol.IsOverride,
IsStatic = methodSymbol.IsStatic,
IsVirtual = methodSymbol.IsVirtual,
Parent = parentType,
Name = methodSymbol.Name,
IsCtor = (methodSymbol.MethodKind == MethodKind.Constructor),
Visibility = methodSymbol.DeclaredAccessibility.ToVisibilityModifierBase(logprovider),
DeclaredReturnType = drt,
Parameters = parameters,
ActualReturnTypes = methodSymbol.GetActualReturnTypes(types, model),
IsGeneric = methodSymbol.IsGenericMethod,
SourceSymbol = methodSymbol,
GenericParameters = CSharpModelBuilder.BuildGenericList(methodSymbol.TypeArguments)
});
}
public static NamedTypeBase ToCSharpNamedType(this ITypeSymbol s, LoggerProvider logprovider)
{
if (s == null)
{
return(null);
}
if (s is IArrayTypeSymbol)
{
var t = (ITypeSymbol)(((IArrayTypeSymbol)s).ElementType);
return(new CSharpNamedType
{
IsArray = true,
Namespace = GetNamespace(t),
IsStatic = t.IsStatic,
IsAbstract = t.IsAbstract,
Visibility = t.DeclaredAccessibility.ToVisibilityModifierBase(logprovider),
Name = t.Name,
SourceSymbol = t
});
}
else
{
var t = s as INamedTypeSymbol;
if (t == null)
{
logprovider.WriteToLog(string.Format("Symbol {0} has an unknown type", s.ToString(), s.TypeKind.ToString()));
}
return(new CSharpNamedType
{
IsArray = false,
IsStatic = t.IsStatic,
Namespace = GetNamespace(t),
IsAbstract = t.IsAbstract,
Visibility = t.DeclaredAccessibility.ToVisibilityModifierBase(logprovider),
IsGeneric = t.IsGenericType,
GenericParameters = CSharpModelBuilder.BuildGenericList(t.TypeArguments),
Name = t.Name,
SourceSymbol = t
});
}
}
static void Main(string[] args)
{
LoggerProvider lp = new LoggerProvider();
var solution = @"EPPlus.sln";
CSharpRecognitionContext ctx = new CSharpRecognitionContext("EPPlus");
ProfilerService.Init(typeof(NullProfiler), (s, t) => { });
using (ProfilerService.Current.Section("Total"))
{
using (ProfilerService.Current.Section("GetCompilations"))
{
ctx.Compilations = CSharpModelBuilder.GetRecognitionContextInputFromSolution(solution);
}
using (ProfilerService.Current.Section("Init"))
{
ctx.Init(lp);
}
SingletonRecognizer srec = new SingletonRecognizer();
srec.Context = ctx;
CompositeRecognizer crec = new CompositeRecognizer();
crec.Context = ctx;
//ProxyRecognizer prec = new ProxyRecognizer();
//prec.Context = ctx;
ChainOfResponsiblityRecognizer correc = new ChainOfResponsiblityRecognizer();
correc.Context = ctx;
FactoryMethodRecognizer frec = new FactoryMethodRecognizer();
frec.Context = ctx;
DecoratorRecognizer drec = new DecoratorRecognizer();
drec.Context = ctx;
MediatorRecognizer mmrec = new MediatorRecognizer();
mmrec.Context = ctx;
Console.Clear();
using (var fres = File.CreateText("results.txt"))
{
foreach (var item in ctx.Types)
{
try
{
if (mmrec.IsInstance(item))
{
Console.WriteLine("{0} is a mediator base", item.ToString());
fres.WriteLine(string.Format("{0} is a singleton", item.ToString()));
}
}
catch
{ }
try
{
if (srec.IsInstance(item))
{
Console.WriteLine(string.Format("{0} is a singleton", item.ToString()));
fres.WriteLine(string.Format("{0} is a singleton", item.ToString()));
}
}
catch (Exception)
{ }
try
{
if (crec.IsInstance(item))
{
Console.WriteLine(string.Format("{0} is a composite", item.ToString()));
fres.WriteLine(string.Format("{0} is a composite", item.ToString()));
}
}
catch (Exception)
{
}
//if (prec.isinstance(item))
//{
// console.writeline(string.format("{0} is a proxy", item.tostring()));
// fres.writeline(string.format("{0} is a proxy", item.tostring()));
//}
try
{
if (correc.IsInstance(item))
{
Console.WriteLine(string.Format("{0} is a chain of responsiblity base", item.ToString()));
fres.WriteLine(string.Format("{0} is a chain of responsiblity base", item.ToString()));
}
}
catch (Exception)
{
}
try
{
if (drec.IsInstance(item))
{
Console.WriteLine(string.Format("{0} is a decorator", item.ToString()));
fres.WriteLine(string.Format("{0} is a decorator", item.ToString()));
}
}
catch (Exception)
{
}
}
foreach (var item in ctx.Types.SelectMany(t => t.Methods))
{
try
{
if (frec.IsInstance(item))
{
Console.WriteLine(string.Format("{0} is a factory method", item.ToString()));
fres.WriteLine(string.Format("{0} is a factory method", item.ToString()));
}
}
catch (Exception)
{
}
}
}
}
Console.ReadLine();
}
