public void ShouldGenerateTypeFromData()
{
Dictionary <string, Type> typeDef = new Dictionary <string, Type>
{
{ "StringProp", typeof(String) },
{ "IntProp", typeof(int) },
{ "DateProp", typeof(DateTime) },
{ "DoubleNullableProp", typeof(double?) }
};
Type t = TypeGenerator.MakeType("NewTypeA", typeDef);
Assert.That("NewTypeA", Is.EqualTo(t.Name));
var pi = t.GetField("StringProp");
Assert.That(typeof(string), Is.EqualTo(pi.FieldType));
pi = t.GetField("IntProp");
Assert.That(typeof(int), Is.EqualTo(pi.FieldType));
pi = t.GetField("DateProp");
Assert.That(typeof(DateTime), Is.EqualTo(pi.FieldType));
pi = t.GetField("DoubleNullableProp");
Assert.That(typeof(double?), Is.EqualTo(pi.FieldType));
IObjectAccessor a = (IObjectAccessor)Activator.CreateInstance(t);
a["StringProp"] = "test";
string s = (string)a["StringProp"];
Assert.That(s, Is.EqualTo("test"));
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
Track track = source as Track;
if (track != null)
{
TypeGenerator generator = new TypeGenerator();
if (track.IncreaseRepeatButton != null)
{
CodeExpression incButton = generator.ProcessGenerators(track.IncreaseRepeatButton, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "IncreaseRepeatButton"), incButton));
}
if (track.DecreaseRepeatButton != null)
{
CodeExpression decButton = generator.ProcessGenerators(track.DecreaseRepeatButton, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "DecreaseRepeatButton"), decButton));
}
if (track.Thumb != null)
{
CodeExpression thumb = generator.ProcessGenerators(track.Thumb, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "Thumb"), thumb));
}
}
return(fieldReference);
}
static void Main(string[] args)
{
var xmlCache = new VkXmlCache(".\\VkTemplates");
var jsonCache = new SpirvJsonCache(".\\VkTemplates");
var parser = new SpecParser(xmlCache, ".\\VkTemplates");
var generator = new TypeGenerator();
var types = generator.Generate(parser.Run());
var fileGenerator = new FileGenerator("..\\..\\..\\SharpVk");
foreach (var modelGenerator in new ModelGenerator <TypeSet>[]
{
new VkCommandsGenerator(),
new VkHandleGenerator(),
new VkDelegateGenerator(),
new VkEnumGenerator(),
new VkStructsGenerator(),
new VkUnionsGenerator(),
new VkExceptionGenerator(),
new VkConstantGenerator(),
new VkInteropStructsGenerator()
})
{
modelGenerator.Run(types, fileGenerator);
}
new SpirvEnumGenerator().Run(jsonCache.GetSpirvModel(), fileGenerator);
var grammarModel = jsonCache.GetSpirvGrammar();
new SpirvOpCodeGenerator().Run(grammarModel, fileGenerator);
new SpirvOperandKindGenerator().Run(grammarModel, fileGenerator);
}
/// <summary>
/// Create the syntax for a field of a class.
/// </summary>
/// <param name="field">Field to create.</param>
/// <returns>The declaration syntax for a field.</returns>
public static FieldDeclarationSyntax Create(Field field)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
var variableDeclarator = VariableDeclarator(Identifier(field.Name));
if (field.InitializeWith != null)
{
variableDeclarator = variableDeclarator.WithInitializer(EqualsValueClause(field.InitializeWith));
}
var fieldDeclaration = FieldDeclaration(VariableDeclaration(TypeGenerator.Create(field.Type), SeparatedList(new[] { variableDeclarator })));
if (field.Modifiers != null)
{
fieldDeclaration = fieldDeclaration.WithModifiers(ModifierGenerator.Create(field.Modifiers.ToArray()));
}
if (field.Attributes != null)
{
fieldDeclaration = fieldDeclaration.WithAttributeLists(AttributeGenerator.Create(field.Attributes.ToArray()));
}
return(fieldDeclaration);
}
private static int GenerateMappint(Mapping mapping, Options opt)
{
var tg = new TypeGenerator();
var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "SourceNs");
var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "TargetNs");
mapping.RebuildRelationships();
var mappings = new Dictionary <int, TypeMapping>();
var sourceItem = mapping.SourceInfo.Roots[0];
var targetItem = mapping.TargetInfo.Roots[0];
var resolver = new TypeResolver();
resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping);
var generator = new Generator();
var sb = new StringBuilder();
var writer = new StringWriter(sb);
generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping);
var entrypointGen = new EntryPointGenerator();
var azureWriter = new OutputWriter();
var codeGen = new List <CodeGenerationResult>()
{
source, target
};
azureWriter.WriteOutput(opt.OutputDirectory, sb.ToString(), entrypointGen.Generate(source.RootType, target.RootType, codeGen), codeGen);
return(0);
}
private object _ResolveSlow(Type type, JsonValue json, IResolver resolver)
{
if (json != null && json.Type == JsonValueType.Object && json.Object.ContainsKey(Constants.TypeKey))
{
var concrete = Type.GetType(json.Object[Constants.TypeKey].String);
return(resolver.Resolve(concrete));
}
if (!_registry.TryGetValue(type, out Type tConcrete))
{
Type typeToLookup = type;
if (type.GetTypeInfo().IsGenericType)
{
typeToLookup = type.GetGenericTypeDefinition();
}
_registry.TryGetValue(typeToLookup, out tConcrete);
}
if (tConcrete != null)
{
if (tConcrete.GetTypeInfo().IsGenericTypeDefinition)
{
tConcrete = tConcrete.MakeGenericType(type.GetTypeArguments());
}
return(resolver.Resolve(tConcrete));
}
if (type.GetTypeInfo().IsInterface)
{
return(TypeGenerator.Generate(type));
}
return(resolver.Resolve(type));
}
/// <summary>
/// Generates code
/// </summary>
/// <param name="source">The dependence object</param>
/// <param name="classType">Type of the class.</param>
/// <param name="initMethod">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod initMethod, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, initMethod, generateField);
DataGrid grid = source as DataGrid;
CodeComHelper.GenerateEnumField <DataGridSelectionMode>(initMethod, fieldReference, source, DataGrid.SelectionModeProperty);
CodeComHelper.GenerateField <bool>(initMethod, fieldReference, source, DataGrid.AutoGenerateColumnsProperty);
CodeComHelper.GenerateEnumField <ScrollBarVisibility>(initMethod, fieldReference, source, DataGrid.HorizontalScrollBarVisibilityProperty);
CodeComHelper.GenerateEnumField <ScrollBarVisibility>(initMethod, fieldReference, source, DataGrid.VerticalScrollBarVisibilityProperty);
if (grid.Columns.Count > 0)
{
TypeGenerator colGenerator = new TypeGenerator();
for (int i = 0; i < grid.Columns.Count; i++)
{
var column = grid.Columns[i];
DataGridColumnGeneratorType.ColumnName = grid.Name + "_Col" + i;
CodeExpression expr = colGenerator.ProcessGenerators(column, classType, initMethod, false);
if (expr == null)
{
continue;
}
initMethod.Statements.Add(new CodeMethodInvokeExpression(fieldReference, "Columns.Add", expr));
}
}
return(fieldReference);
}
/// <summary>
/// Create the local declaration statement syntax to declare a local variable and assign it an already created expression.
/// </summary>
/// <param name="name">Name of the variable.</param>
/// <param name="type">Type of the variable.</param>
/// <param name="expressionSyntax">An already created expression to assign to the variable.</param>
/// <param name="castTo">Cast the expression to this type.</param>
/// <param name="useVarKeyword">Will use "var" keyword if true, otherwise the type.</param>
/// <returns>The generated local declaration statement.</returns>
public LocalDeclarationStatementSyntax DeclareAndAssign(string name, Type type, ExpressionSyntax expressionSyntax, Type castTo = null, bool useVarKeyword = true)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(name));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (expressionSyntax == null)
{
throw new ArgumentNullException(nameof(expressionSyntax));
}
if (castTo != null && castTo != typeof(void))
{
expressionSyntax = CastExpression(TypeGenerator.Create(castTo), expressionSyntax);
}
return(LocalDeclarationStatement(VariableDeclaration(useVarKeyword ? IdentifierName("var") : TypeGenerator.Create(type))
.WithVariables(SingletonSeparatedList(VariableDeclarator(Identifier(name))
.WithInitializer(EqualsValueClause(expressionSyntax))))));
}
public void ShouldGenerateObjectFromData()
{
var now = DateTime.Now;
Dictionary <string, object> objDef = new Dictionary <string, object>
{
{ "StringProp", "test data" },
{ "IntProp", 48 },
{ "DateProp", now },
{ "DoubleProp", 45.98 }
};
var obj = TypeGenerator.MakeObject("NewTypeB", objDef);
Type t = obj.GetType();
Assert.That("NewTypeB", Is.EqualTo(t.Name));
var pi = t.GetField("StringProp");
Assert.That(typeof(string), Is.EqualTo(pi.FieldType));
Assert.That(pi.GetValue(obj), Is.EqualTo("test data"));
pi = t.GetField("IntProp");
Assert.That(typeof(int), Is.EqualTo(pi.FieldType));
Assert.That(pi.GetValue(obj), Is.EqualTo(48));
pi = t.GetField("DateProp");
Assert.That(typeof(DateTime), Is.EqualTo(pi.FieldType));
Assert.That(pi.GetValue(obj), Is.EqualTo(now));
pi = t.GetField("DoubleProp");
Assert.That(typeof(double), Is.EqualTo(pi.FieldType));
Assert.That(pi.GetValue(obj), Is.EqualTo(45.98));
}
private static List <Task <GenerationResult> > ProcessFilesInDir(string dir, string inputDir, string outputDir)
{
var tasks = new List <Task <GenerationResult> >();
foreach (var fi in Directory.EnumerateFiles(dir, "*.json"))
{
// ../Geometry/Vector3.json => Geometry/
var schemaSubDir = Path.GetDirectoryName(fi).Replace(inputDir, ".");
var outDir = Path.GetFullPath(Path.Combine(outputDir, schemaSubDir));
if (!Directory.Exists(outDir))
{
Console.WriteLine($"Creating a new directory {outDir}...");
Directory.CreateDirectory(outDir);
}
var classPath = Path.Combine(outDir, Path.GetFileNameWithoutExtension(fi) + ".g.cs");
if (File.Exists(classPath))
{
File.Delete(classPath);
}
var schema = File.ReadAllText(fi);
tasks.Add(TypeGenerator.GenerateUserElementTypeFromJsonAsync(schema, outDir));
}
return(tasks);
}
private static void Main(string[] args)
{
#if false
TypeManager typeMgr = new TypeManager();
typeMgr.Load(@"../../CodeGenTester/bin/debug/CodeGenTester.exe");
TestCodeGen(typeMgr);
#endif
#if true
TypeManager typeMgr = new TypeManager();
typeMgr.Load(@"../../MSILTester/bin/debug/MSILTester.exe");
TestReferenceMarker(typeMgr);
#endif
#if false
var sw = new Stopwatch();
sw.Start();
typeMgr.AddEntry(typeMgr.Module.EntryPoint);
typeMgr.Process();
sw.Stop();
Console.WriteLine("Elapsed: {0}ms", sw.ElapsedMilliseconds);
TypeGenerator typeGen = new TypeGenerator(typeMgr);
typeGen.GenerateAll();
#endif
}
protected override ArgumentSyntax CreateArgumentSyntax()
{
var syntaxNodeOrTokens = new List <SyntaxNodeOrToken>();
foreach (var dictionaryValue in _dictionary)
{
syntaxNodeOrTokens.Add(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(dictionaryValue.Key),
dictionaryValue.Value.GetArgumentSyntax().Expression));
syntaxNodeOrTokens.Add(Token(SyntaxKind.CommaToken));
}
if (syntaxNodeOrTokens.Any())
{
syntaxNodeOrTokens.RemoveAt(syntaxNodeOrTokens.Count - 1);
}
return(Argument(
ObjectCreationExpression(TypeGenerator.Create(type)).WithInitializer(
InitializerExpression(
SyntaxKind.ObjectInitializerExpression,
SeparatedList <ExpressionSyntax>(syntaxNodeOrTokens.ToArray())))));
}
public void ThrowsWithBadSchema()
{
var uris = new [] { "https://raw.githubusercontent.com/hypar-io/Schemas/master/ThisDoesn'tExist.json",
"https://raw.githubusercontent.com/hypar-io/Schemas/master/Mullion.json" };
Assert.Throws <Exception>(() => TypeGenerator.GenerateInMemoryAssemblyFromUrisAndLoad(uris));
}
static void RemoveCircularDependencies(Type type, HashSet <Type> types)
{
var incTypes = types.Where(x => x != typeof(Object) &&
x != typeof(ValueType) &&
!IsBaseType(x, type) && !x.IsReallyEnum()).ToList();
foreach (var subType in incTypes)
{
HashSet <Type> subTypes = new HashSet <Type> ();
TypeGenerator.AddIncludes(subType, subTypes);
subTypes.RemoveWhere(x => x == subType || x == typeof(char));
if (subType == typeof(System.Threading.Tasks.Task))
{
subTypes.RemoveWhere(x => x == typeof(System.Threading.Tasks.Task <>));
}
Filter(subType, subTypes, true);
if (subTypes.Contains(type) && !IsEnumeratorOf(subType, type))
{
types.RemoveWhere(x => x == subType);
}
}
if (type == typeof(System.Runtime.InteropServices.UCOMIMoniker))
{
types.RemoveWhere(x => x == typeof(System.Runtime.InteropServices.UCOMIStream) || x == typeof(System.Runtime.InteropServices.UCOMIBindCtx));
}
if (type == typeof(System.Runtime.InteropServices.ComTypes.IMoniker))
{
types.RemoveWhere(x => x == typeof(System.Runtime.InteropServices.ComTypes.IStream) || x == typeof(System.Runtime.InteropServices.ComTypes.IBindCtx));
}
}
public static IMethodSymbol RenameTypeParameters(this IMethodSymbol method, IList <string> newNames)
{
if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames))
{
return(method);
}
var typeGenerator = new TypeGenerator();
var updatedTypeParameters = RenameTypeParameters(
method.TypeParameters, newNames, typeGenerator);
// The use of AllNullabilityIgnoringSymbolComparer is tracked by https://github.com/dotnet/roslyn/issues/36093
var mapping = new Dictionary <ITypeSymbol, ITypeSymbol>(AllNullabilityIgnoringSymbolComparer.Instance);
for (var i = 0; i < method.TypeParameters.Length; i++)
{
mapping[method.TypeParameters[i]] = updatedTypeParameters[i];
}
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
method.ContainingType,
method.GetAttributes(),
method.DeclaredAccessibility,
method.GetSymbolModifiers(),
method.GetReturnTypeWithAnnotatedNullability().SubstituteTypes(mapping, typeGenerator),
method.RefKind,
method.ExplicitInterfaceImplementations,
method.Name,
updatedTypeParameters,
method.Parameters.SelectAsArray(p =>
CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.GetTypeWithAnnotatedNullability().SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional,
p.HasExplicitDefaultValue, p.HasExplicitDefaultValue ? p.ExplicitDefaultValue : null))));
}
public static IMethodSymbol RenameTypeParameters(this IMethodSymbol method, ImmutableArray <string> newNames)
{
if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames))
{
return(method);
}
var typeGenerator = new TypeGenerator();
var updatedTypeParameters = RenameTypeParameters(
method.TypeParameters, newNames, typeGenerator);
var mapping = new Dictionary <ITypeSymbol, ITypeSymbol>(SymbolEqualityComparer.Default);
for (var i = 0; i < method.TypeParameters.Length; i++)
{
mapping[method.TypeParameters[i]] = updatedTypeParameters[i];
}
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
method.ContainingType,
method.GetAttributes(),
method.DeclaredAccessibility,
method.GetSymbolModifiers(),
method.ReturnType.SubstituteTypes(mapping, typeGenerator),
method.RefKind,
method.ExplicitInterfaceImplementations,
method.Name,
updatedTypeParameters,
method.Parameters.SelectAsArray(p =>
CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional,
p.HasExplicitDefaultValue, p.HasExplicitDefaultValue ? p.ExplicitDefaultValue : null))));
}
public async Task GeneratesInMemoryAssembly()
{
var uris = new[] { "https://raw.githubusercontent.com/hypar-io/Schemas/master/FacadeAnchor.json",
"https://raw.githubusercontent.com/hypar-io/Schemas/master/Mullion.json" };
var asm = await TypeGenerator.GenerateInMemoryAssemblyFromUrisAndLoadAsync(uris);
var mullionType = asm.GetType("Test.Foo.Bar.Mullion");
var anchorType = asm.GetType("Test.Foo.Bar.FacadeAnchor");
Assert.NotNull(mullionType);
Assert.NotNull(anchorType);
Assert.NotNull(mullionType.GetProperty("CenterLine"));
Assert.NotNull(mullionType.GetProperty("Profile"));
Assert.NotNull(anchorType.GetProperty("Location"));
var ctors = mullionType.GetConstructors();
Assert.Single <ConstructorInfo>(ctors);
var centerLine = new Line(new Vector3(0, 0), new Vector3(5, 5));
var profile = new Profile(Polygon.Rectangle(0.1, 0.1));
// Profile @profile, Line @centerLine, NumericProperty @length, Transform @transform, Material @material, Representation @representation, System.Guid @id, string @name
var t = new Transform();
var m = BuiltInMaterials.Steel;
var mullion = Activator.CreateInstance(mullionType, new object[] { profile, centerLine, new NumericProperty(0, NumericPropertyUnitType.Length), t, m, new Representation(new List <SolidOperation>()), false, Guid.NewGuid(), "Test Mullion" });
}
public void Visit(SpecParser.ParsedExpressionReference reference, ExpressionBuildState state)
{
reference.LeftOperand.Visit(this, state);
state.Builder.Append(".");
var targetType = typeData[state.ExpressionType];
var memberMappings = targetType.Data.Members
.Where(x => x.Dimensions != null)
.ToDictionary(x => ((SpecParser.ParsedExpressionToken)x.Dimensions[0].Value).Value);
var member = targetType.Data.Members.Single(x => x.VkName == reference.RightOperand.Value);
string memberName;
if (memberMappings.ContainsKey(member.VkName))
{
memberName = TypeGenerator.GetNameForElement(memberMappings[member.VkName]) + ".Length";
}
else
{
memberName = TypeGenerator.GetNameForElement(member);
}
state.Builder.Append(memberName);
state.ExpressionType = member.Type;
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
Track track = source as Track;
if (track != null)
{
CodeComHelper.GenerateField<bool>(method, fieldReference, source, Track.IsDirectionReversedProperty);
TypeGenerator generator = new TypeGenerator();
if (track.IncreaseRepeatButton != null)
{
CodeExpression incButton = generator.ProcessGenerators(track.IncreaseRepeatButton, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "IncreaseRepeatButton"), incButton));
}
if (track.DecreaseRepeatButton != null)
{
CodeExpression decButton = generator.ProcessGenerators(track.DecreaseRepeatButton, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "DecreaseRepeatButton"), decButton));
}
if (track.Thumb != null)
{
CodeExpression thumb = generator.ProcessGenerators(track.Thumb, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "Thumb"), thumb));
}
}
return fieldReference;
}
public static bool CreateDefault(Type type, out object defaultValue)
{
try {
defaultValue = Activator.CreateInstance(type);
return(true);
} catch (Exception) {
foreach (var creator in _defaultInstanceCreators)
{
if (creator.HandlesType(type))
{
defaultValue = creator.CreateDefault(type);
return(true);
}
}
}
var typeName = TypeGenerator.Generate(type);
if (EditorUtility.DisplayDialog(
"No IDefaultInstanceCreator found",
"There's no IDefaultInstanceCreator implementation to handle the type '" + typeName + "'.\n" +
"Providing an IDefaultInstanceCreator enables you to create instances for that type.\n\n" +
"Do you want to generate an IDefaultInstanceCreator implementation for '" + typeName + "'?\n",
"Generate",
"Cancel"
))
{
generateIDefaultInstanceCreator(typeName);
}
defaultValue = null;
return(false);
}
/// <summary>
/// Generates code
/// </summary>
/// <param name="source">The dependence object</param>
/// <param name="classType">Type of the class.</param>
/// <param name="initMethod">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod initMethod, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, initMethod, generateField);
DataGrid grid = source as DataGrid;
CodeComHelper.GenerateEnumField<DataGridSelectionMode>(initMethod, fieldReference, source, DataGrid.SelectionModeProperty);
CodeComHelper.GenerateField<bool>(initMethod, fieldReference, source, DataGrid.AutoGenerateColumnsProperty);
CodeComHelper.GenerateField<bool>(initMethod, fieldReference, source, DataGrid.EnableRowVirtualizationProperty);
CodeComHelper.GenerateEnumField<ScrollBarVisibility>(initMethod, fieldReference, source, DataGrid.HorizontalScrollBarVisibilityProperty);
CodeComHelper.GenerateEnumField<ScrollBarVisibility>(initMethod, fieldReference, source, DataGrid.VerticalScrollBarVisibilityProperty);
if (grid.Columns.Count > 0)
{
TypeGenerator colGenerator = new TypeGenerator();
for (int i = 0; i < grid.Columns.Count; i++)
{
var column = grid.Columns[i];
DataGridColumnGeneratorType.ColumnName = grid.Name + "_Col" + i;
CodeExpression expr = colGenerator.ProcessGenerators(column, classType, initMethod, false);
if (expr == null)
{
continue;
}
initMethod.Statements.Add(new CodeMethodInvokeExpression(fieldReference, "Columns.Add", expr));
}
}
return fieldReference;
}
public void CanGenerateCodeForVariantMapping()
{
var tg = new TypeGenerator();
var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestFiles.AToXVariantMapping));
var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "Source");
var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "Target");
Write(source.Code);
Write(target.Code);
mapping.RebuildRelationships();
var mappings = new Dictionary <int, TypeMapping>();
var sourceItem = mapping.SourceInfo.Roots[0];
var targetItem = mapping.TargetInfo.Roots[0];
var resolver = new TypeResolver();
resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping);
var generator = new Generator();
var sb = new StringBuilder();
var writer = new StringWriter(sb);
generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping);
var result = sb.ToString();
Write(result);
Assert.True(result.Contains("target.Z = MapNoTitleToZ(Source?.B);"), "Array was correctly passed as a parameter");
Assert.True(result.Contains("public virtual Target.Z MapNoTitleToZ(IEnumerable<Source.Anonymous> B)"), "array was correctly added as method argument");
}
public void CanGenerateCodeForNestedMapping()
{
var tg = new TypeGenerator();
var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestFiles.AToXMapping));
var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "Mapping");
var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "Mapping");
Write(source.Code);
Write(target.Code);
mapping.RebuildRelationships();
var mappings = new Dictionary <int, TypeMapping>();
var sourceItem = mapping.SourceInfo.Roots[0];
var targetItem = mapping.TargetInfo.Roots[0];
var resolver = new TypeResolver();
resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping);
var generator = new Generator();
var sb = new StringBuilder();
var writer = new StringWriter(sb);
generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping);
Write(sb.ToString());
}
private void GenerateType(SourceGeneratorContext context, INamedTypeSymbol type)
{
var structure = new JsonType(type);
var code = TypeGenerator.Generate(structure);
context.AddSource($"{type.Name}.Generated.cs", SourceText.From(code, Encoding.UTF8));
}
private static void _AssignObjectProperties(out object?obj, Type type, DeserializationContext context)
{
obj = type.GetTypeInfo().IsInterface
? TypeGenerator.Generate(type)
: context.RootSerializer.Options.Resolver.Resolve(type, context.ValueMap);
_AssignObjectProperties(ref obj, context.ValueMap);
}
public async Task MergesModelsWithUserDefinedTypes()
{
var schemas = new[] {
"../../../models/Merge/Envelope.json",
"../../../models/Merge/FacadePanel.json",
"../../../models/Merge/Level.json"
};
var asm = await TypeGenerator.GenerateInMemoryAssemblyFromUrisAndLoadAsync(schemas);
var facadePanelType = asm.Assembly.GetType("Elements.FacadePanel");
Assert.NotNull(facadePanelType);
var envelopeType = asm.Assembly.GetType("Elements.Envelope");
Assert.NotNull(envelopeType);
var model1 = JsonConvert.DeserializeObject <Model>(File.ReadAllText("../../../models/Merge/facade.json"));
var count1 = model1.Elements.Count;
var model2 = JsonConvert.DeserializeObject <Model>(File.ReadAllText("../../../models/Merge/structure.json"));
var count2 = model2.Elements.Count;
var merge = new Model();
merge.AddElements(model1.Elements.Values);
merge.AddElements(model2.Elements.Values);
merge.ToGlTF("models/Merge.glb");
}
public void ShouldBeJsonSerializable()
{
var now = DateTime.Now;
Dictionary <string, object> objDef = new Dictionary <string, object>
{
{ "StringProp", "test data" },
{ "IntProp", 48 },
{ "DateProp", now },
{ "DoubleProp", 45.98 },
{ "ArrayProp", new [] { 1, 3, 5, 7 } },
{ "ListProp", new List <string>(new [] { "a", "b", "c" }) }
};
var obj = TypeGenerator.MakeObject(null, objDef);
string s = JsonConvert.SerializeObject(obj, Formatting.Indented);
Console.WriteLine(s);
var obj2 = (IObjectAccessor)JsonConvert.DeserializeObject(s, obj.GetType());
Assert.That(obj2["StringProp"], Is.EqualTo("test data"));
Assert.That(obj2["IntProp"], Is.EqualTo(48));
Assert.That(obj2["DateProp"], Is.EqualTo(now));
Assert.That(obj2["DoubleProp"], Is.EqualTo(45.98));
Assert.That(obj2.GetValue <int[]>("ArrayProp").Length, Is.EqualTo(4));
Assert.That(obj2.GetValue <List <string> >("ListProp").Count, Is.EqualTo(3));
}
// public static bool CompatibleSignatureToDelegate(this IMethodSymbol method, INamedTypeSymbol delegateType)
// {
// //Contract.ThrowIfFalse(delegateType.TypeKind == TypeKind.Delegate);
//
// var invoke = delegateType.DelegateInvokeMethod;
// if (invoke == null)
// {
// // It's possible to get events with no invoke method from metadata. We will assume
// // that no method can be an event handler for one.
// return false;
// }
//
// if (method.Parameters.Length != invoke.Parameters.Length)
// {
// return false;
// }
//
// if (method.ReturnsVoid != invoke.ReturnsVoid)
// {
// return false;
// }
//
// if (!method.ReturnType.InheritsFromOrEquals(invoke.ReturnType))
// {
// return false;
// }
//
// for (int i = 0; i < method.Parameters.Length; i++)
// {
// if (!invoke.Parameters[i].Type.InheritsFromOrEquals(method.Parameters[i].Type))
// {
// return false;
// }
// }
//
// return true;
// }
//
public static IMethodSymbol RenameTypeParameters(this IMethodSymbol method, IList<string> newNames)
{
if (method.TypeParameters.Select(t => t.Name).SequenceEqual(newNames))
{
return method;
}
var typeGenerator = new TypeGenerator();
var updatedTypeParameters = RenameTypeParameters(
method.TypeParameters, newNames, typeGenerator);
var mapping = new Dictionary<ITypeSymbol, ITypeSymbol>();
for (int i = 0; i < method.TypeParameters.Length; i++)
{
mapping.Add(method.TypeParameters[i], updatedTypeParameters[i]);
}
return CodeGenerationSymbolFactory.CreateMethodSymbol(
method.ContainingType,
method.GetAttributes(),
method.DeclaredAccessibility,
method.GetSymbolModifiers(),
method.ReturnType.SubstituteTypes(mapping, typeGenerator),
method.ExplicitInterfaceImplementations.FirstOrDefault(),
method.Name,
updatedTypeParameters,
method.Parameters.Select(p =>
CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional,
p.HasExplicitDefaultValue, p.HasExplicitDefaultValue ? p.ExplicitDefaultValue : null)).ToList());
}
/// <summary>
/// Generates code
/// </summary>
/// <param name="source">The dependence object</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The initialize method.</param>
/// <param name="generateField"></param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
ItemsControl itemsControl = source as ItemsControl;
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemsPanelProperty);
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemTemplateProperty);
if (itemsControl.Items.Count > 0)
{
TypeGenerator typeGenerator = new TypeGenerator();
ValueGenerator valueGenerator = new ValueGenerator();
CodeMemberMethod itemsMethod = new CodeMemberMethod();
itemsMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private;
itemsMethod.Name = "Get_" + itemsControl.Name + "_Items";
itemsMethod.ReturnType = new CodeTypeReference(typeof(ObservableCollection <object>));
classType.Members.Add(itemsMethod);
CodeVariableDeclarationStatement collection = new CodeVariableDeclarationStatement(
typeof(ObservableCollection <object>), "items", new CodeObjectCreateExpression(typeof(ObservableCollection <object>)));
itemsMethod.Statements.Add(collection);
CodeVariableReferenceExpression itemsVar = new CodeVariableReferenceExpression("items");
foreach (var item in itemsControl.Items)
{
Type itemType = item.GetType();
CodeExpression itemExpr = null;
if (typeGenerator.HasGenerator(itemType))
{
itemExpr = typeGenerator.ProcessGenerators(item, classType, itemsMethod, false);
}
else
{
itemExpr = valueGenerator.ProcessGenerators(classType, itemsMethod, item, itemsControl.Name);
}
if (itemExpr != null)
{
CodeMethodInvokeExpression addItem = new CodeMethodInvokeExpression(itemsVar, "Add", itemExpr);
itemsMethod.Statements.Add(addItem);
}
else
{
CodeComHelper.GenerateError(itemsMethod, string.Format("Type {0} in Items Control collection not supported", itemType.Name));
}
}
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(itemsVar);
itemsMethod.Statements.Add(returnStatement);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "ItemsSource"),
new CodeMethodInvokeExpression(null, itemsMethod.Name)));
}
return(fieldReference);
}
public void CreateObject()
{
TypeDefine def = new TypeDefine("DynamicTypeTest", "SampleObject");
TypeGenerator g = new TypeGenerator(def);
Type t = g.Generate();
Assert.AreEqual("SampleObject", t.Name);
}
public void SingleAttributeTypeDataTest()
{
var generator = new TypeGenerator();
var type = typeof(System.IComparable);
var result = generator.Generate(type);
Assert.AreEqual("System.IComparable", result);
}
public void CreateMultipleAsyncTypeOfTheSameKind_Expected_SameTypeReturned()
{
var generator = new TypeGenerator();
var asynchType1 = generator.GenerateAsyncInterfaceFor <ISyncInterface>();
var asynchType2 = generator.GenerateAsyncInterfaceFor <ISyncInterface>();
Assert.AreEqual(asynchType1, asynchType2);
}
public void MethodCall_Success()
{
var instance = TypeGenerator.Generate <IInterface>();
var actual = instance.RequiredMethod <int, IConvertible>(2.0);
Assert.AreEqual(default(int), actual);
}
public Type Build(ProxyDefinition proxyDefinition)
{
var typeMetadata = ProxyMetadataFactory.BuildTypeMetadata(proxyDefinition);
var generator = new TypeGenerator(_moduleBuilder, _proxyNamespace, typeMetadata);
return generator.Generate();
}
/// <summary>
/// Generates code
/// </summary>
/// <param name="source">The dependence object</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The initialize method.</param>
/// <param name="generateField"></param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
ItemsControl itemsControl = source as ItemsControl;
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemsPanelProperty);
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, ItemsControl.ItemTemplateProperty);
if (itemsControl.Items.Count > 0)
{
TypeGenerator typeGenerator = new TypeGenerator();
ValueGenerator valueGenerator = new ValueGenerator();
CodeMemberMethod itemsMethod = new CodeMemberMethod();
itemsMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private;
itemsMethod.Name = "Get_" + itemsControl.Name + "_Items";
itemsMethod.ReturnType = new CodeTypeReference(typeof(ObservableCollection<object>));
classType.Members.Add(itemsMethod);
CodeVariableDeclarationStatement collection = new CodeVariableDeclarationStatement(
typeof(ObservableCollection<object>), "items", new CodeObjectCreateExpression(typeof(ObservableCollection<object>)));
itemsMethod.Statements.Add(collection);
CodeVariableReferenceExpression itemsVar = new CodeVariableReferenceExpression("items");
foreach (var item in itemsControl.Items)
{
Type itemType = item.GetType();
CodeExpression itemExpr = null;
if (typeGenerator.HasGenerator(itemType))
{
itemExpr = typeGenerator.ProcessGenerators(item, classType, itemsMethod, false);
}
else
{
itemExpr = valueGenerator.ProcessGenerators(classType, itemsMethod, item, itemsControl.Name);
}
if (itemExpr != null)
{
CodeMethodInvokeExpression addItem = new CodeMethodInvokeExpression(itemsVar, "Add", itemExpr);
itemsMethod.Statements.Add(addItem);
}
else
{
CodeComHelper.GenerateError(itemsMethod, string.Format("Type {0} in Items Control collection not supported", itemType.Name));
}
}
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(itemsVar);
itemsMethod.Statements.Add(returnStatement);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "ItemsSource"),
new CodeMethodInvokeExpression(null, itemsMethod.Name)));
}
return fieldReference;
}
public DelegatingTypeGenerator(params Type[] interfaces)
{
_generator = new TypeGenerator(typeof(object), "Interceptor", "InterceptedObject");
foreach (var interfaceType in interfaces)
{
_generator.Implements(interfaceType);
}
_generator.AddConstructor(Constructor);
_generator.AddField("__interceptionService", typeof(IDynamicImplementation), FieldAttributes.Private | FieldAttributes.InitOnly, ref __interceptionService);
_generator.WhenMethodImplementationRequired(ImplementMethod);
_generator.WhenPropertyImplementationRequired(ImplementProperty);
_generator.WhenEventImplementationRequired(ImplementEvent);
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="initMethod">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod initMethod, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, initMethod, generateField);
HeaderedItemsControl control = source as HeaderedItemsControl;
UIElement header = control.Header as UIElement;
if (header != null)
{
TypeGenerator headerGenerator = new TypeGenerator();
CodeExpression headerExpr = headerGenerator.ProcessGenerators(header, classType, initMethod, false);
initMethod.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "Header"), headerExpr));
}
else if (control.Header != null)
{
CodeComHelper.GenerateField<object>(initMethod, fieldReference, source, HeaderedContentControl.HeaderProperty);
// TODO content can be another class, so this will not work
}
return fieldReference;
}
private static Tuple<bool, TypeGenerator> GetBuiltin(bool isForHelp, TypeGenerator generator)
{
return new Tuple<bool, TypeGenerator>(isForHelp, generator);
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public virtual CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
DataGridColumn column = source as DataGridColumn;
string typeName = source.GetType().Name;
string name = ColumnName;
CodeExpression fieldReference = new CodeVariableReferenceExpression(name);
CodeTypeReference variableType = new CodeTypeReference(typeName);
CodeVariableDeclarationStatement declaration = new CodeVariableDeclarationStatement(variableType, name);
declaration.InitExpression = new CodeObjectCreateExpression(typeName);
method.Statements.Add(declaration);
if (CodeComHelper.IsValidForFieldGenerator(source.ReadLocalValue(DataGridColumn.WidthProperty)))
{
DataGridLength value = (DataGridLength)source.GetValue(DataGridColumn.WidthProperty);
if (value.UnitType == DataGridLengthUnitType.Pixel)
{
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, DataGridColumn.WidthProperty.Name),
new CodePrimitiveExpression((float)value.Value)));
}
}
CodeComHelper.GenerateFieldDoubleToFloat(method, fieldReference, source, DataGridColumn.MaxWidthProperty);
CodeComHelper.GenerateFieldDoubleToFloat(method, fieldReference, source, DataGridColumn.MinWidthProperty);
CodeComHelper.GenerateEnumField<Visibility>(method, fieldReference, source, DataGridColumn.VisibilityProperty);
CodeComHelper.GenerateField<string>(method, fieldReference, source, DataGridColumn.SortMemberPathProperty);
UIElement header = column.Header as UIElement;
if (header != null)
{
TypeGenerator headerGenerator = new TypeGenerator();
CodeExpression headerExpr = headerGenerator.ProcessGenerators(header, classType, method, false);
method.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "Header"), headerExpr));
}
else if (column.Header != null)
{
CodeComHelper.GenerateField<object>(method, fieldReference, source, DataGridColumn.HeaderProperty);
// TODO content can be another class, so this will not work
}
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, DataGridColumn.HeaderStyleProperty, name + "_h");
return fieldReference;
}
private static IList<ITypeParameterSymbol> RenameTypeParameters(
IList<ITypeParameterSymbol> typeParameters,
IList<string> newNames,
TypeGenerator typeGenerator)
{
// We generate the type parameter in two passes. The first creates the new type
// parameter. The second updates the constraints to point at this new type parameter.
var newTypeParameters = new List<CodeGenerationTypeParameterSymbol>();
var mapping = new Dictionary<ITypeSymbol, ITypeSymbol>();
for (int i = 0; i < typeParameters.Count; i++)
{
var typeParameter = typeParameters[i];
var newTypeParameter = new CodeGenerationTypeParameterSymbol(
typeParameter.ContainingType,
typeParameter.GetAttributes(),
typeParameter.Variance,
newNames[i],
typeParameter.ConstraintTypes,
typeParameter.HasConstructorConstraint,
typeParameter.HasReferenceTypeConstraint,
typeParameter.HasValueTypeConstraint,
typeParameter.Ordinal);
newTypeParameters.Add(newTypeParameter);
mapping.Add(typeParameter, (ITypeSymbol)newTypeParameter.Instance);
}
// Now we update the constraints.
foreach (var newTypeParameter in newTypeParameters)
{
newTypeParameter.ConstraintTypes = ImmutableArray.CreateRange(newTypeParameter.ConstraintTypes, t => t.SubstituteTypes(mapping, typeGenerator));
}
return newTypeParameters.Cast<ITypeParameterSymbol>().ToList();
}
public void Should_Be_Able_To_Add_Fields()
{
Type generatedType = new TypeGenerator().CreateType(type =>
{
type.Named("TestType10");
type.AddField<string>("field1");
type.AddField<BaseType>("field2");
});
Assert.AreEqual(2, generatedType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Length);
Assert.AreEqual(typeof(string), generatedType.GetField("field1", BindingFlags.NonPublic | BindingFlags.Instance).FieldType);
Assert.AreEqual(typeof(BaseType), generatedType.GetField("field2", BindingFlags.NonPublic | BindingFlags.Instance).FieldType);
}
