//-----------------------------------------------------------------------------------------------------------------------------------------------------
private ConstructorMember DefineConstructor(ConstructorMethodFactory factory)
{
var constructorMember = new ConstructorMember(OwnerClass, factory);
OwnerClass.AddMember(constructorMember);
return(constructorMember);
}
public void CanEmitConstructorDeclaration(
string expectedCode,
MemberVisibility visibility,
MemberModifier modifier,
Delegate signaturePrototype,
Action <ConstructorMember> constructorSetup)
{
//-- arrange
var constructor = new ConstructorMember(visibility, modifier, "ClassOne", new MethodSignature(signaturePrototype.GetMethodInfo()));
if (constructorSetup != null)
{
constructorSetup(constructor);
}
var enclosingClassMember = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
enclosingClassMember.Members.Add(constructor);
var enclosingClassEmitter = new ClassSyntaxEmitter(enclosingClassMember);
var expectedClassCode = "public class ClassOne { " + expectedCode + " }";
//-- act
var actualClassSyntax = enclosingClassEmitter.EmitSyntax();
//-- assert
actualClassSyntax.Should().BeEquivalentToCode(expectedClassCode);
}
public void Visit_ConstructorBodyStatementsIncluded()
{
//-- arrange
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var constructor1 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "ClassOne", new MethodSignature());
var variable1 = new LocalVariable {
Name = "x", Type = typeof(TimeSpan)
};
constructor1.Body = new BlockStatement(
new VariableDeclarationStatement {
Variable = variable1
}
);
type1.Members.Add(constructor1);
var foundTypes = new HashSet <TypeMember>();
var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes);
//-- act
type1.AcceptVisitor(visitorUnderTest);
//-- assert
foundTypes.Should().BeEquivalentTo(new TypeMember[] {
type1, typeof(TimeSpan)
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private FieldMember[] DefinePrimaryConstructor(Func <MethodMember, AttributeWriter> attributes, params object[] argumentNameTypePairs)
{
if ((argumentNameTypePairs.Length % 2) != 0)
{
throw new ArgumentException("argumentNameTypePairs must be of even length");
}
var argumentNames = new string[argumentNameTypePairs.Length / 2];
var fieldNames = new string[argumentNameTypePairs.Length / 2];
var fieldTypes = new Type[argumentNameTypePairs.Length / 2];
for (int i = 0; i < fieldNames.Length; i++)
{
var name = (string)argumentNameTypePairs[i * 2];
argumentNames[i] = name.Substring(0, 1).ToLower() + name.Substring(1);
fieldNames[i] = "m_" + name;
fieldTypes[i] = (Type)argumentNameTypePairs[i * 2 + 1];
}
var constructorMember = new ConstructorMember(OwnerClass, ConstructorMethodFactory.InstanceConstructor(OwnerClass, fieldTypes, argumentNames));
OwnerClass.AddMember(constructorMember);
var fieldMembers = fieldTypes.Select((type, index) => DefineField(fieldNames[index], type, isStatic: false)).ToArray();
var constructorWriter = new PrimaryConstructorWriter(constructorMember, fieldMembers);
constructorWriter.AddAttributes(attributes);
return(fieldMembers);
}
public void ReadDeclaration()
{
_member = new ConstructorMember {
DeclaringType = _modelBuilder.TryGetMember <TypeMember>(_symbol.ContainingType),
Status = MemberStatus.Incomplete,
Visibility = _symbol.GetMemberVisibility(),
Modifier = _symbol.GetMemberModifier(),
Signature = MethodReaderMechanism.ReadSignature(_modelBuilder, _symbol),
};
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void VisitConstructor(ConstructorMember methodMember)
{
var decoratorFactory = new LazyFactory <ConstructorDecorationBuilder>(() =>
(ConstructorDecorationBuilder) new DecoratingConstructorWriter(methodMember).DecorationBuilder);
if (methodMember.IsStatic)
{
OnStaticConstructor(methodMember, decoratorFactory.GetObject);
}
else
{
OnConstructor(methodMember, decoratorFactory.GetObject);
}
}
public override void VisitConstructor(ConstructorMember constructor)
{
base.VisitConstructor(constructor);
if (constructor.CallThisConstructor != null)
{
constructor.CallThisConstructor.AcceptVisitor(_statementVisitor);
}
if (constructor.CallBaseConstructor != null)
{
constructor.CallBaseConstructor.AcceptVisitor(_statementVisitor);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private TypeMember BuildClassWithIntAndStringProperties(TypeKey key)
{
var classType = new TypeMember(new TypeGeneratorInfo(this.GetType(), key), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var intValueProperty = new PropertyMember {
Visibility = MemberVisibility.Public, PropertyType = typeof(int), Name = "IntValue"
};
var stringValueProperty = new PropertyMember {
Visibility = MemberVisibility.Public, PropertyType = typeof(string), Name = "StringValue"
};
var constructor = new ConstructorMember(
MemberVisibility.Public,
MemberModifier.None,
"ClassOne",
new MethodSignature(new MethodParameter[] {
new MethodParameter("intValue", 1, typeof(int)),
new MethodParameter("stringValue", 2, typeof(string)),
}, null, false)
);
constructor.Body = new BlockStatement(
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new MemberExpression {
Target = new ThisExpression(), Member = intValueProperty
},
Right = new ParameterExpression {
Parameter = constructor.Signature.Parameters.First(p => p.Name == "intValue")
},
}
},
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new MemberExpression {
Target = new ThisExpression(), Member = stringValueProperty
},
Right = new ParameterExpression {
Parameter = constructor.Signature.Parameters.First(p => p.Name == "stringValue")
},
}
}
);
classType.Members.Add(constructor);
classType.Members.Add(intValueProperty);
classType.Members.Add(stringValueProperty);
return(classType);
}
public void Visit_ConstructorDelegationCallIncluded()
{
//-- arrange
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var type2 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS2", MemberVisibility.Public, TypeMemberKind.Class, "ClassTwo");
MethodCallExpression baseConstructorCall;
var constructor1 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "ClassOne", new MethodSignature())
{
CallBaseConstructor = baseConstructorCall = new MethodCallExpression()
};
baseConstructorCall.Arguments.Add(new Argument {
Expression = new NewObjectExpression {
Type = type2
}
});
MethodCallExpression thisConstructorCall;
var constructor2 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "ClassOne", new MethodSignature())
{
CallThisConstructor = thisConstructorCall = new MethodCallExpression()
};
thisConstructorCall.Arguments.Add(new Argument {
Expression = new NewObjectExpression {
Type = typeof(System.IO.MemoryStream)
}
});
type1.Members.Add(constructor1);
type1.Members.Add(constructor2);
var foundTypes = new HashSet <TypeMember>();
var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes);
//-- act
type1.AcceptVisitor(visitorUnderTest);
//-- assert
foundTypes.Should().BeEquivalentTo(new TypeMember[] {
type1, type2, typeof(System.IO.MemoryStream)
});
}
public DefaultConstructorWriter(ConstructorMember ownerConstructor)
: base(ownerConstructor, script: null)
{
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public ConstructorWriter(ConstructorMember ownerConstructor, Action <ConstructorWriter> script)
: base(ownerConstructor)
{
m_OwnerConstructor = ownerConstructor;
m_Script = script;
}
public void CanVisitAppliedAttributes()
{
//-- arrange
var classAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A1")
};
var fieldAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A2")
};
var constructorAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A3")
};
var constructorParamAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A3B")
};
var methodAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A4")
};
var methodParamAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A4B")
};
var methodRetValAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A4C")
};
var propertyAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A5")
};
var propertyGetterAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A5")
};
var propertySetterAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A5")
};
var eventAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A6")
};
var eventAdderAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A6B")
};
var eventRemoverAttribute1 = new AttributeDescription()
{
AttributeType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "A6C")
};
var class1 = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "Class1");
class1.Attributes.Add(classAttribute1);
#region Build class type members
var field1 = new FieldMember(class1, MemberVisibility.Private, MemberModifier.None, typeof(int), "_field1");
field1.Attributes.Add(fieldAttribute1);
var constructor1 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "Class1", new MethodSignature(
new[] { new MethodParameter("n", 1, typeof(int), MethodParameterModifier.None, constructorParamAttribute1) },
returnValue: null,
isAsync: false
));
constructor1.Attributes.Add(constructorAttribute1);
var method1 = new MethodMember(MemberVisibility.Public, MemberModifier.None, "M1", new MethodSignature(
new[] { new MethodParameter("n", 1, typeof(int), MethodParameterModifier.None, methodParamAttribute1) },
returnValue: new MethodParameter(null, -1, typeof(string), MethodParameterModifier.None, methodRetValAttribute1),
isAsync: false
));
method1.Attributes.Add(methodAttribute1);
var property1 = new PropertyMember(class1, MemberVisibility.Public, MemberModifier.None, typeof(int), "P1");
property1.Getter = new MethodMember(property1.Visibility, "get_" + property1.Name);
property1.Setter = new MethodMember(property1.Visibility, "set_" + property1.Name);
property1.Attributes.Add(propertyAttribute1);
property1.Getter.Attributes.Add(propertyGetterAttribute1);
property1.Setter.Attributes.Add(propertySetterAttribute1);
var event1 = new EventMember(MemberVisibility.Public, MemberModifier.None, typeof(Action), "E1");
event1.Adder = new MethodMember(event1.Visibility, "add_" + event1.Name);
event1.Remover = new MethodMember(event1.Visibility, "remove_" + event1.Name);
event1.Attributes.Add(eventAttribute1);
event1.Adder.Attributes.Add(eventAdderAttribute1);
event1.Remover.Attributes.Add(eventRemoverAttribute1);
#endregion
class1.Members.AddRange(new AbstractMember[] {
field1, constructor1, method1, property1, event1
});
var visitLog = new List <Visit>();
var visitor = new TestMemberVisitor(visitLog);
//-- act
class1.AcceptVisitor(visitor);
//-- assert
visitLog.Should().ContainInOrder(
new Visit(nameof(MemberVisitor.VisitAttribute), classAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), fieldAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), constructorAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), constructorParamAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), methodAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), methodParamAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), methodRetValAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), propertyAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), propertyGetterAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), propertySetterAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), eventAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), eventAdderAttribute1),
new Visit(nameof(MemberVisitor.VisitAttribute), eventRemoverAttribute1)
);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public PrimaryConstructorWriter(ConstructorMember ownerConstructor, FieldMember[] fieldsToInitialize)
: base(ownerConstructor, script: null)
{
m_FieldsToInitialize = fieldsToInitialize;
}
public void CanGenerateHardCodedArtifactClass()
{
//-- arrange
var artifactType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "FirstArtifact");
artifactType.BaseType = new TypeMember(typeof(RuntimeTypeFactoryArtifact <>).MakeGenericType(typeof(IFirstContract)));
artifactType.Interfaces.Add(new TypeMember(typeof(IConstructor <>).MakeGenericType(typeof(IFirstContract))));
var constructor = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "FirstArtifact", new MethodSignature());
constructor.CallBaseConstructor = new MethodCallExpression();
var typeKeyConstructorCall = new MethodCallExpression();
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = typeof(TestFactory)
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = typeof(IFirstContract)
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression()
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression()
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = 0
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = 0
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = 0
}
});
constructor.CallBaseConstructor.Arguments.Add(new Argument {
Expression = new NewObjectExpression {
Type = typeof(TypeKey),
ConstructorCall = typeKeyConstructorCall
}
});
constructor.CallBaseConstructor.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = typeof(FirstContractImplementation)
}
});
var factoryMethod = new MethodMember(
MemberVisibility.Public,
MemberModifier.None,
nameof(IConstructor <object> .NewInstance),
new MethodSignature {
ReturnValue = new MethodParameter {
Type = typeof(IFirstContract)
}
});
factoryMethod.Body = new BlockStatement(
new ReturnStatement {
Expression = new NewObjectExpression {
Type = typeof(FirstContractImplementation)
}
}
);
var singletonMethod = new MethodMember(
MemberVisibility.Public,
MemberModifier.None,
nameof(IConstructor <object> .GetOrCreateSingleton),
new MethodSignature {
ReturnValue = new MethodParameter {
Type = typeof(IFirstContract)
}
});
singletonMethod.Body = new BlockStatement(
new ThrowStatement {
Exception = new NewObjectExpression {
Type = typeof(NotSupportedException)
}
}
);
artifactType.Members.Add(constructor);
artifactType.Members.Add(factoryMethod);
artifactType.Members.Add(singletonMethod);
//-- act
var syntaxEmitter = new ClassSyntaxEmitter(artifactType);
SyntaxNode actualSyntax;
using (TypeMemberTagCache.CreateOnCurrentThread())
{
actualSyntax = syntaxEmitter.EmitSyntax();
}
//-- assert
var expectedCode = @"
public class FirstArtifact :
NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifact<NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract>,
NWheels.Compilation.Mechanism.Factories.IConstructor<NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract>
{
public FirstArtifact() : base(
new NWheels.Compilation.Mechanism.Factories.TypeKey(
typeof(NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.TestFactory),
typeof(NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract),
null, null, 0, 0, 0),
typeof(NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.FirstContractImplementation))
{
}
public NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract NewInstance()
{
return new NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.FirstContractImplementation();
}
public NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract GetOrCreateSingleton()
{
throw new System.NotSupportedException();
}
}
";
actualSyntax.Should().BeEquivalentToCode(expectedCode);
}
public void CanVisitTypeMembers()
{
//-- arrange
var class1 = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "Class1");
var field1 = new FieldMember(class1, MemberVisibility.Private, MemberModifier.None, typeof(int), "_field1");
var field2 = new FieldMember(class1, MemberVisibility.Private, MemberModifier.None, typeof(int), "_field2");
var constructor1 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "Class1", new MethodSignature());
var constructor2 = new ConstructorMember(MemberVisibility.Public, MemberModifier.Static, "Class1", new MethodSignature());
var method1 = new MethodMember(MemberVisibility.Public, MemberModifier.None, "M1", new MethodSignature());
var method2 = new MethodMember(MemberVisibility.Public, MemberModifier.None, "M2", new MethodSignature());
var property1 = new PropertyMember(class1, MemberVisibility.Public, MemberModifier.None, typeof(int), "P1");
var property2 = new PropertyMember(class1, MemberVisibility.Public, MemberModifier.None, typeof(int), "P2");
var event1 = new EventMember(MemberVisibility.Public, MemberModifier.None, typeof(Action), "E1");
var event2 = new EventMember(MemberVisibility.Public, MemberModifier.None, typeof(Action), "E2");
class1.Members.AddRange(new AbstractMember[] {
field1, field2, constructor1, constructor2, method1, method2, property1, property2, event1, event2
});
property2.Getter = new MethodMember(property2.Visibility, "get_" + property2.Name);
property2.Setter = new MethodMember(property2.Visibility, "set_" + property2.Name);
event2.Adder = new MethodMember(property2.Visibility, "add_" + event2.Name);
event2.Remover = new MethodMember(property2.Visibility, "remove_" + event2.Name);
var visitLog = new List <Visit>();
var visitor = new TestMemberVisitor(visitLog);
//-- act
class1.AcceptVisitor(visitor);
//-- assert
visitLog.Should().Equal(
new Visit(nameof(MemberVisitor.VisitAbstractMember), class1),
new Visit(nameof(MemberVisitor.VisitTypeMember), class1),
new Visit(nameof(MemberVisitor.VisitClassType), class1),
new Visit(nameof(MemberVisitor.VisitAbstractMember), field1),
new Visit(nameof(MemberVisitor.VisitField), field1),
new Visit(nameof(MemberVisitor.VisitAbstractMember), field2),
new Visit(nameof(MemberVisitor.VisitField), field2),
new Visit(nameof(MemberVisitor.VisitAbstractMember), constructor1),
new Visit(nameof(MemberVisitor.VisitMethodBase), constructor1),
new Visit(nameof(MemberVisitor.VisitConstructor), constructor1),
new Visit(nameof(MemberVisitor.VisitAbstractMember), constructor2),
new Visit(nameof(MemberVisitor.VisitMethodBase), constructor2),
new Visit(nameof(MemberVisitor.VisitConstructor), constructor2),
new Visit(nameof(MemberVisitor.VisitAbstractMember), method1),
new Visit(nameof(MemberVisitor.VisitMethodBase), method1),
new Visit(nameof(MemberVisitor.VisitMethod), method1),
new Visit(nameof(MemberVisitor.VisitAbstractMember), method2),
new Visit(nameof(MemberVisitor.VisitMethodBase), method2),
new Visit(nameof(MemberVisitor.VisitMethod), method2),
new Visit(nameof(MemberVisitor.VisitAbstractMember), property1),
new Visit(nameof(MemberVisitor.VisitProperty), property1),
new Visit(nameof(MemberVisitor.VisitAbstractMember), property2),
new Visit(nameof(MemberVisitor.VisitProperty), property2),
new Visit(nameof(MemberVisitor.VisitAbstractMember), property2.Getter),
new Visit(nameof(MemberVisitor.VisitMethodBase), property2.Getter),
new Visit(nameof(MemberVisitor.VisitMethod), property2.Getter),
new Visit(nameof(MemberVisitor.VisitAbstractMember), property2.Setter),
new Visit(nameof(MemberVisitor.VisitMethodBase), property2.Setter),
new Visit(nameof(MemberVisitor.VisitMethod), property2.Setter),
new Visit(nameof(MemberVisitor.VisitAbstractMember), event1),
new Visit(nameof(MemberVisitor.VisitEvent), event1),
new Visit(nameof(MemberVisitor.VisitAbstractMember), event2),
new Visit(nameof(MemberVisitor.VisitEvent), event2),
new Visit(nameof(MemberVisitor.VisitAbstractMember), event2.Adder),
new Visit(nameof(MemberVisitor.VisitMethodBase), event2.Adder),
new Visit(nameof(MemberVisitor.VisitMethod), event2.Adder),
new Visit(nameof(MemberVisitor.VisitAbstractMember), event2.Remover),
new Visit(nameof(MemberVisitor.VisitMethodBase), event2.Remover),
new Visit(nameof(MemberVisitor.VisitMethod), event2.Remover)
);
}
public ConstructorReader(CodeModelBuilder modelBuilder, IMethodSymbol symbol)
{
_modelBuilder = modelBuilder;
_symbol = symbol;
_member = null;
}
public virtual void VisitConstructor(ConstructorMember constructor)
{
VisitMethodBase(constructor);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
public override void VisitConstructor(ConstructorMember constructor)
{
base.VisitConstructor(constructor);
_visitLog.Add(new Visit(nameof(VisitConstructor), constructor));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void ImplementArtifactConstructor(TypeMember productType, TypeKey key, TypeMember artifactType)
{
var constructor = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, artifactType.Name, new MethodSignature());
constructor.CallBaseConstructor = new MethodCallExpression();
var typeKeyConstructorCall = new MethodCallExpression();
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.FactoryType
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.PrimaryContract
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.SecondaryContract1
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.SecondaryContract2
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.SecondaryContract3
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.ExtensionValue1
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.ExtensionValue2
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = key.ExtensionValue3
}
});
constructor.CallBaseConstructor.Arguments.Add(new Argument {
Expression = new NewObjectExpression {
Type = typeof(TypeKey),
ConstructorCall = typeKeyConstructorCall
}
});
constructor.CallBaseConstructor.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = productType
}
});
artifactType.Members.Add(constructor);
}
public void SetUp(List <string> args)
{
if (verbose)
{
Console.WriteLine("import path:");
foreach (string directory in pathResolver.Directories)
{
Console.WriteLine(" " + directory);
}
}
AppDomain domain = Thread.GetDomain();
rootModule = new Module(null, null);
foreach (Assembly assembly in domain.GetAssemblies())
{
AssemblyLoaded(assembly);
}
domain.AssemblyLoad += OnDomainAssemblyLoad;
rootModule.SetName("null", null);
rootModule.SetName("true", true);
rootModule.SetName("false", false);
rootModule.SetName("args", args);
DefaultWhitespace.SetUp(rootModule, grammar);
LineComment.SetUp(rootModule, grammar);
BlockComment.SetUp(rootModule, grammar);
Whitespace.SetUp(rootModule, grammar);
Name.SetUp(rootModule, grammar);
Name.SetUp(rootModule, grammar);
Number.SetUp(rootModule, grammar);
Base.String.SetUp(rootModule, grammar);
Expression.SetUp(rootModule, grammar);
ValueExpression.SetUp(rootModule, grammar);
NameExpression.SetUp(rootModule, grammar);
ParenExpression.SetUp(rootModule, grammar);
MemberExpression.SetUp(rootModule, grammar);
CallExpression.SetUp(rootModule, grammar);
CallInParentScopeExpression.SetUp(rootModule, grammar);
NewExpression.SetUp(rootModule, grammar);
TypeExpression.SetUp(rootModule, grammar);
IsExpression.SetUp(rootModule, grammar);
AsExpression.SetUp(rootModule, grammar);
UnaryExpression.SetUp(rootModule, grammar);
NotExpression.SetUp(rootModule, grammar);
MultiplicativeExpression.SetUp(rootModule, grammar);
MultiplyExpression.SetUp(rootModule, grammar);
DivideExpression.SetUp(rootModule, grammar);
AdditiveExpression.SetUp(rootModule, grammar);
AddExpression.SetUp(rootModule, grammar);
SubtractExpression.SetUp(rootModule, grammar);
ComparisonExpression.SetUp(rootModule, grammar);
LessExpression.SetUp(rootModule, grammar);
LessOrEqualExpression.SetUp(rootModule, grammar);
EqualityExpression.SetUp(rootModule, grammar);
InequalityExpression.SetUp(rootModule, grammar);
GreaterExpression.SetUp(rootModule, grammar);
GreaterOrEqualExpression.SetUp(rootModule, grammar);
JunctionExpression.SetUp(rootModule, grammar);
AndExpression.SetUp(rootModule, grammar);
AssignmentExpression.SetUp(rootModule, grammar);
AssignExpression.SetUp(rootModule, grammar);
/*
* NameExpression = ValueExpression
* ParenExpression = ValueExpression
*
* CallExpression < ValueExpression
* CallInParentScopeExpression = CallExpression
* MemberExpression = CallExpression
*
* NewExpression < CallExpression
* TypeExpression < NewExpression
* UnaryExpression < TypeExpression
* MultiplicativeExpression < UnaryExpression
* AdditiveExpression < MultiplicativeExpression
* ComparisonExpression < AdditiveExpression
* JunctionExpression < ComparisonExpression
* AssignmentExpression < JunctionExpression
*/
Precedence.SetPrecedence(NameExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(ParenExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(CallExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(CallInParentScopeExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(MemberExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(NewExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(TypeExpression.pattern.Precedence,
NewExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(UnaryExpression.pattern.Precedence,
TypeExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(MultiplicativeExpression.pattern.Precedence,
UnaryExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AdditiveExpression.pattern.Precedence,
MultiplicativeExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(ComparisonExpression.pattern.Precedence,
AdditiveExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(JunctionExpression.pattern.Precedence,
ComparisonExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AssignmentExpression.pattern.Precedence,
JunctionExpression.pattern.Precedence, Relation.Lower);
Grammar.PatternChanged(ValueExpression.pattern,
NameExpression.pattern,
ParenExpression.pattern,
MemberExpression.pattern,
CallExpression.pattern,
NewExpression.pattern,
TypeExpression.pattern,
UnaryExpression.pattern,
MultiplicativeExpression.pattern,
AdditiveExpression.pattern,
ComparisonExpression.pattern,
JunctionExpression.pattern,
AssignmentExpression.pattern);
PatternExpression.SetUp(rootModule, grammar);
ReferencePatternExpression.SetUp(rootModule, grammar);
AnyPatternExpression.SetUp(rootModule, grammar);
TextPatternExpression.SetUp(rootModule, grammar);
Option.SetUp(rootModule, grammar);
BlockPatternExpression.SetUp(rootModule, grammar);
ParenPatternExpression.SetUp(rootModule, grammar);
TokenPatternExpression.SetUp(rootModule, grammar);
RangePatternExpression.SetUp(rootModule, grammar);
RepeatPatternExpression.SetUp(rootModule, grammar);
AndPatternExpression.SetUp(rootModule, grammar);
NotPatternExpression.SetUp(rootModule, grammar);
LabelPatternExpression.SetUp(rootModule, grammar);
SequencePatternExpression.SetUp(rootModule, grammar);
AltPatternExpression.SetUp(rootModule, grammar);
/*
* EndPatternExpression = ReferencePatternExpression
* AnyPatternExpression = ReferencePatternExpression
* TextPatternExpression = ReferencePatternExpression
* BlockPatternExpression = ReferencePatternExpression
* ParenPatternExpression = ReferencePatternExpression
* TokenPatternExpression = ReferencePatternExpression
*
* RangePatternExpression < ReferencePatternExpression
*
* AndPatternExpression < RangePatternExpression
* NotPatternExpression = AndPatternExpression
* RepeatPatternExpression = AndPatternExpression
*
* LabelPatternExpression < AndPatternExpression
* SequencePatternExpression < LabelPatternExpression
* AltPatternExpression < SequencePatternExpression
*/
Precedence.SetPrecedence(AnyPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(TextPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(BlockPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(ParenPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(TokenPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(RangePatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AndPatternExpression.pattern.Precedence,
RangePatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(NotPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(RepeatPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(LabelPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(SequencePatternExpression.pattern.Precedence,
LabelPatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AltPatternExpression.pattern.Precedence,
SequencePatternExpression.pattern.Precedence, Relation.Lower);
Grammar.PatternChanged(ReferencePatternExpression.pattern,
AnyPatternExpression.pattern,
TextPatternExpression.pattern,
BlockPatternExpression.pattern,
ParenPatternExpression.pattern,
TokenPatternExpression.pattern,
RangePatternExpression.pattern,
RepeatPatternExpression.pattern,
AndPatternExpression.pattern,
NotPatternExpression.pattern,
LabelPatternExpression.pattern,
SequencePatternExpression.pattern,
AltPatternExpression.pattern);
Statement.SetUp(rootModule, grammar);
ExpressionStatement.SetUp(rootModule, grammar);
CompoundStatement.SetUp(rootModule, grammar);
PrintStatement.SetUp(rootModule, grammar);
IfStatement.SetUp(rootModule, grammar);
WhileStatement.SetUp(rootModule, grammar);
ReturnStatement.SetUp(rootModule, grammar);
ThrowStatement.SetUp(rootModule, grammar);
TryStatement.SetUp(rootModule, grammar);
ModuleStatement.SetUp(rootModule, grammar);
FunctionStatement.SetUp(rootModule, grammar);
Member.SetUp(rootModule, grammar);
PatternMember.SetUp(rootModule, grammar);
FieldMember.SetUp(rootModule, grammar);
ConstructorMember.SetUp(rootModule, grammar);
MethodMember.SetUp(rootModule, grammar);
ClassStatement.SetUp(rootModule, grammar);
SetPrecedenceStatement.SetUp(rootModule, grammar);
UsingStatement.SetUp(rootModule, grammar);
ImportStatement.SetUp(rootModule, grammar);
TopLevelStatement.SetUp(rootModule, grammar);
Program.SetUp(rootModule, grammar);
Grammar.PatternChanged(Member.pattern, Statement.pattern);
grammar.RootPattern = Program.pattern;
hasBeenSetUp = true;
}
