public ReadOnlyInterfaceMethod(InterfaceMethod interfaceMethod)
{
this.interfaceMethod = interfaceMethod;
genericParameters = ReadOnlyGenericParameterDeclaration.Create(interfaceMethod.GenericParameters);
parameters = ReadOnlyMethodParameter.Create(interfaceMethod.Parameters);
returnType = new ReadOnlyTypeReference(interfaceMethod.ReturnType);
}
public static void Main(string[] args)
{
//AsyncContext.Run(GenerateVisitorInterface);
string baseDirectory = Path.GetFullPath(
Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), @"..\..\..\.."));
AssemblyWithReflection assembly = new AssemblyWithReflection(typeof(ClassWithCodeAnalysis).Assembly);
Interface visitorInterface = new Interface("ICodeAnalysisVisitor");
IEnumerable <string> classNames =
from @class in assembly.AllClasses
let baseClassName = @class.BaseClass?.Name
where baseClassName != null &&
baseClassName.StartsWith("Editable") &&
!baseClassName.Contains("Expression") &&
!baseClassName.Contains("Statement")
let className = @class.Name
orderby className
select className;
foreach (string className in classNames)
{
string parameterName = Regex.Replace(className, "WithCodeAnalysis$", "");
parameterName = parameterName.Substring(0, 1).ToLower() + parameterName.Substring(1);
InterfaceMethod method = new InterfaceMethod($"Visit{className}")
{
ReturnType = new TypeReference(typeof(void)),
Parameters = new Collection <MethodParameter>()
{
new MethodParameter(parameterName, new TypeReference(className))
}
};
visitorInterface.Body.Methods.Add(method);
}
Console.WriteLine(visitorInterface.ToString());
}
public void Interface_Methods()
{
const string code = @"
public interface Interface1
{
string Method1(int param, Interface1 i);
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceMethod inter = (InterfaceMethod)clazz.WalkChildren()[0];
Assert.That(inter.Name, Is.EqualTo("Method1"));
Assert.That(inter.ReturnType.ToString(), Is.EqualTo("string"));
Assert.That(inter.Parameters, Has.Count(2));
Assert.That(inter.Parameters[0].Name, Is.EqualTo("param"));
Assert.That(inter.Parameters[0].DataType, Is.EqualTo("int"));
Assert.That(inter.Parameters[1].Name, Is.EqualTo("i"));
Assert.That(inter.Parameters[1].DataType, Is.EqualTo("Interface1"));
}
public void InterfaceMethodBasicFeature()
{
var md = new InterfaceMethod("GetNumber");
Assert.AreEqual("void GetNumber();" + SourceCodeGenerator.NewLine
, SourceCodeGenerator.Write(SourceCodeLanguage.CSharp, md));
}
public void GenericInterfaceMethod_WithConstraints()
{
const string code = @"
public interface Interface1
{
string Method1<T>(int param, T i) where T : class;
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
if (parser.ErrorOccurred)
{
Assert.Fail(parser.GetFormattedErrors());
}
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceMethod inter = (InterfaceMethod)clazz.WalkChildren()[0];
Assert.That(inter.Name, Is.EqualTo("Method1"));
Assert.That(inter.GenericParameters.Count, Is.EqualTo(1));
Assert.That(inter.GenericParameters[0], Is.EqualTo("T"));
Assert.That(inter.GenericConstraintClause, Is.EqualTo("where T : class"));
Assert.That(inter.ReturnType.ToString(), Is.EqualTo("string"));
Assert.That(inter.Parameters, Has.Count(2));
Assert.That(inter.Parameters[0].Name, Is.EqualTo("param"));
Assert.That(inter.Parameters[0].DataType, Is.EqualTo("int"));
Assert.That(inter.Parameters[1].Name, Is.EqualTo("i"));
Assert.That(inter.Parameters[1].DataType, Is.EqualTo("T"));
}
public void InterfaceMethodParameters()
{
var md = new InterfaceMethod("GetDisplayName");
md.Parameters.Add(new MethodParameter("String", "name"));
md.Parameters.Add(new MethodParameter("Int32", "age"));
Assert.AreEqual("void GetDisplayName(String name, Int32 age);" + SourceCodeGenerator.NewLine
, SourceCodeGenerator.Write(SourceCodeLanguage.CSharp, md));
}
public void InterfaceMethodPartialFeature()
{
var md = new InterfaceMethod("GetNumber");
//These will be ignored
md.Parameters.Add(new MethodParameter("Int32", "number"));
md.GenericParameters.Add("T");
md.ReturnTypeName = new TypeName("Int32");
Assert.AreEqual("Int32 GetNumber<T>(Int32 number);" + SourceCodeGenerator.NewLine
, SourceCodeGenerator.Write(SourceCodeLanguage.CSharp, md));
}
protected CodeRoot CreateInterfaceAndMethod(string parameterName)
{
InterfaceMethod inter = new InterfaceMethod(controller, "Method1");
inter.ReturnType = new DataType(controller, "int");
Parameter param = new Parameter(controller);
param.Name = parameterName;
param.DataType = "int";
inter.Parameters.Add(param);
return(CreateNamespaceAndInterface(inter));
}
public void An_InterfaceMethod_Is_Created()
{
const string code = "void Method1();";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.InterfaceMethodDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(InterfaceMethod)));
InterfaceMethod con = (InterfaceMethod)bc;
Assert.That(con.Name, Is.EqualTo("Method1"));
Assert.That(con.ReturnType.Name, Is.EqualTo("void"));
}
public (IParseFunction, IReadOnlyList <InterfaceMethod>) Visit(Sequence target, INodeType input)
{
var interfaceMethods = new List <InterfaceMethod>();
InterfaceMethod interfaceMethod = null;
var types = target.Steps.Where(i => i.IsReturned).Select(i => i.Function.ReturnType).ToList();
if (types.Count > 0)
{
var name = $"{interfaceMethodName}{++count}";
interfaceMethod = new InterfaceMethod(input, name, types);
interfaceMethods.Add(interfaceMethod);
}
return(new Sequence(target.Steps, interfaceMethod), interfaceMethods);
}
public void InterfaceMethod()
{
Interface it = new Interface(controller, "Interface1");
InterfaceMethod item = new InterfaceMethod(controller, "Function1", new DataType(controller, "int"));
item.Parameters.Add(new Parameter(controller, "float", "f"));
item.Parameters.Add(new Parameter(controller, "InputObject", "j"));
Assert.That(item.FullyQualifiedDisplayName, Is.EqualTo("Function1 (float, InputObject)"));
it.AddChild(item);
Namespace ns = new Namespace(controller);
ns.Name = "ns1";
ns.AddChild(it);
Assert.That(item.FullyQualifiedDisplayName, Is.EqualTo("ns1.Interface1.Function1 (float, InputObject)"));
}
private void BasicTargetWithInterfaceMethod(IParseFunction target, InterfaceMethod interfaceMethod, Signature signature)
{
var resultName = "r";
var nodeName = $"{resultName}.Node";
var invoker = this.invokers[target];
writer.VarAssign(resultName, invoker("input", "inputPosition", "states", "factory")); // Invocation
writer.IfNullReturnNull(resultName);
var decl = new Decl(target.ReturnType, nodeName);
var returnExpression = GetReturnExpression(target.ReturnType, new[] { decl }, $"{resultName}.Advanced", "factory", interfaceMethod);
if (signature.IsMemoized)
{
var memField = NameGen.MemoizedFieldName(signature.Name);
returnExpression = $"states[inputPosition].{memField} = {returnExpression}";
}
writer.Return(returnExpression);
}
public void InterfaceBasicFeature()
{
var c = new Interface("IPerson");
var p = new InterfaceProperty("Int32", "Age", true, true);
c.Properties.Add(p);
var md = new InterfaceMethod("GetNumber");
c.Methods.Add(md);
Assert.AreEqual("public interface IPerson" + SourceCodeGenerator.NewLine
+ "{" + SourceCodeGenerator.NewLine
+ " Int32 Age { get; set; }" + SourceCodeGenerator.NewLine
+ SourceCodeGenerator.NewLine
+ " void GetNumber();" + SourceCodeGenerator.NewLine
+ "}" + SourceCodeGenerator.NewLine
, SourceCodeGenerator.Write(SourceCodeLanguage.CSharp, c));
}
private static async Task GenerateVisitorInterface()
{
string baseDirectory = Path.GetFullPath(
Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), @"..\..\..\.."));
ProjectWithCodeAnalysis project = await ProjectWithCodeAnalysis.OpenAsync(
Path.Combine(baseDirectory, @"CSharpDom.CodeAnalysis\CSharpDom.CodeAnalysis.csproj"));
LoadedProjectWithCodeAnalysis loadedProject = await project.LoadAsync();
Interface visitorInterface = new Interface("ICodeAnalysisVisitor");
IEnumerable <string> classNames =
from @class in loadedProject.AllClasses
let baseClassName = @class.BaseClass?.Name
where baseClassName != null &&
baseClassName.StartsWith("Editable") &&
!baseClassName.Contains("Expression") &&
!baseClassName.Contains("Statement")
let className = @class.Name
orderby className
select className;
foreach (string className in classNames)
{
string parameterName = Regex.Replace(className, "WithCodeAnalysis$", "");
parameterName = parameterName.Substring(0, 1).ToLower() + parameterName.Substring(1);
InterfaceMethod method = new InterfaceMethod($"Visit{className}")
{
ReturnType = new TypeReference(typeof(void)),
Parameters = new Collection <MethodParameter>()
{
new MethodParameter(parameterName, new TypeReference(className))
}
};
visitorInterface.Body.Methods.Add(method);
}
Console.WriteLine(visitorInterface.ToString());
}
public (IParseFunction, IReadOnlyList <InterfaceMethod>) Visit(Selection target, INodeType input)
{
var interfaceMethods = new List <InterfaceMethod>();
var newSteps = new List <SelectionStep>();
foreach (var step in target.Steps)
{
IParseFunction func = step.Function;
INodeType funcReturnType = func.ReturnType;
InterfaceMethod interfaceMethod = null;
if (input != EmptyNodeType.Instance)
{
var name = $"{interfaceMethodName}{++count}";
interfaceMethod = new InterfaceMethod(input, name, GetParameterTypesFromReturnType(funcReturnType));
interfaceMethods.Add(interfaceMethod);
}
var newStep = new SelectionStep(func, interfaceMethod);
newSteps.Add(newStep);
}
return(new Selection(newSteps), interfaceMethods);
}
public InterfaceMethodPrinter(InterfaceMethod obj)
: base(obj)
{
this.obj = obj;
}
private static String GetReturnExpression(INodeType returnType, IReadOnlyList <Decl> nodes, String inputPositionReference, String factoryName, InterfaceMethod interfaceMethod)
{
String nodeString;
if (returnType == EmptyNodeType.Instance)
{
nodeString = "EmptyNode.Instance";
}
else if (interfaceMethod != null)
{
String param;
if (nodes.Count == 1 && nodes[0].Type == EmptyNodeType.Instance)
{
param = String.Empty;
}
else
{
param = String.Join(", ", nodes.Select(i => i.Name));
}
nodeString = $"{factoryName}.{interfaceMethod.Name}({param})";
}
else if (nodes.Count == 1)
{
nodeString = nodes[0].Name;
}
else
{
// Make a tuple
nodeString = $"({String.Join(", ", nodes.Select(i => i.Name))})";
}
var returnTypeString = returnType.GetParseResultTypeString();
return($"new {returnTypeString}({nodeString}, {inputPositionReference})");
}
protected CodeRoot CreateInterfaceAndMethod(string parameterName)
{
InterfaceMethod inter = new InterfaceMethod(controller, "Method1");
inter.ReturnType = new DataType(controller, "int");
Parameter param = new Parameter(controller);
param.Name = parameterName;
param.DataType = "int";
inter.Parameters.Add(param);
return CreateNamespaceAndInterface(inter);
}
public void InterfaceMethod()
{
Interface it = new Interface(controller, "Interface1");
InterfaceMethod item = new InterfaceMethod(controller, "Function1", new DataType(controller, "int"));
item.Parameters.Add(new Parameter(controller, "float", "f"));
item.Parameters.Add(new Parameter(controller, "InputObject", "j"));
Assert.That(item.FullyQualifiedDisplayName, Is.EqualTo("Function1 (float, InputObject)"));
it.AddChild(item);
Namespace ns = new Namespace(controller);
ns.Name = "ns1";
ns.AddChild(it);
Assert.That(item.FullyQualifiedDisplayName, Is.EqualTo("ns1.Interface1.Function1 (float, InputObject)"));
}
public void ImplementsAdd(InterfaceMethod interfaceString)
{
mImplementList.Add(interfaceString);
}
public VBInterfaceMethodPrinter(InterfaceMethod obj)
{
this.obj = obj;
}
public void InterfaceMethod_Change_DataType()
{
const string name = "MyInterfaceMethod1";
DataType type1 = new DataType(controller, DataType1);
DataType type2 = new DataType(controller, DataType2);
const string expectedResult = DataType2 + " " + name;
InterfaceMethod merged1 = new InterfaceMethod(controller, name);
InterfaceMethod merged2 = new InterfaceMethod(controller, name);
InterfaceMethod merged3 = new InterfaceMethod(controller, name);
InterfaceMethod unchanging = new InterfaceMethod(controller, name, type1);
InterfaceMethod changing = new InterfaceMethod(controller, name, type2);
Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult);
}
public void InterfaceMethod_Add_HasNewKeyword()
{
const string name = "MyInterfaceMethod1";
DataType type1 = new DataType(controller, DataType1);
const string expectedResult = "new " + DataType1 + " " + name;
InterfaceMethod merged1 = new InterfaceMethod(controller, name);
InterfaceMethod merged2 = new InterfaceMethod(controller, name);
InterfaceMethod merged3 = new InterfaceMethod(controller, name);
InterfaceMethod unchanging = new InterfaceMethod(controller, name, type1);
InterfaceMethod changing = new InterfaceMethod(controller, name, type1);
changing.HasNewKeyword = true;
Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult);
}
private void Process_Interace_Method_Declaration(InterfaceMethodDeclaration node)
{
if (node == null) throw new ArgumentNullException("node");
InterfaceMethod inter = new InterfaceMethod(controller, node.Name.Text);
inter.ReturnType = FormatterUtility.GetDataTypeFromTypeReference(node.ReturnType, document, controller);
foreach (ParameterDeclaration paramNode in node.Parameters)
{
inter.Parameters.Add(GetParameterFromParameterDeclaration(document, controller, paramNode));
}
if (node.IsGenericMethodDefinition)
{
List<string> genericTypeReferences = new List<string>();
List<string> genericParameterContraints = new List<string>();
foreach (TypeReference gtp in node.GenericTypeArguments)
{
Process_Generic_Type_Argument(gtp, genericTypeReferences, genericParameterContraints);
}
inter.GenericParameters.AddRange(genericTypeReferences);
if (genericParameterContraints.Count > 0)
{
inter.GenericConstraintClause = string.Format("where {0}", string.Join(", ", genericParameterContraints.ToArray()));
}
}
SetupBaseConstruct(node, inter);
}
public VBInterfaceMethodPrinter(InterfaceMethod obj)
{
this.obj = obj;
}
public InterfaceMethodPrinter(InterfaceMethod obj)
: base(obj)
{
this.obj = obj;
}
