internal void Remove(Type sourceType, Type destinationType) { var key = new TypeTuple(sourceType, destinationType); Remove(key); }
/// <summary> /// Item1 - True, if isExpression returns true /// Item2 - If Item1 is true, it contains the type of the alias that is defined in the isExpression /// </summary> private Tuple<bool, AbstractType> evalIsExpression_EvalSpecToken(IsExpression isExpression, AbstractType typeToCheck, bool DoAliasHandling = false) { bool r = false; AbstractType res = null; switch (isExpression.TypeSpecializationToken) { /* * To handle semantic tokens like "return" or "super" it's just needed to * look into the current resolver context - * then, we'll be able to gather either the parent method or the currently scoped class definition. */ case DTokens.Struct: case DTokens.Union: case DTokens.Class: case DTokens.Interface: if (r = typeToCheck is UserDefinedType && ((TemplateIntermediateType)typeToCheck).Definition.ClassType == isExpression.TypeSpecializationToken) res = typeToCheck; break; case DTokens.Enum: if (!(typeToCheck is EnumType)) break; { var tr = (UserDefinedType)typeToCheck; r = true; res = tr.Base; } break; case DTokens.Function: case DTokens.Delegate: if (typeToCheck is DelegateType) { var isFun = false; var dgr = (DelegateType)typeToCheck; if (!dgr.IsFunctionLiteral) r = isExpression.TypeSpecializationToken == ( (isFun = ((DelegateDeclaration)dgr.DeclarationOrExpressionBase).IsFunction) ? DTokens.Function : DTokens.Delegate); // Must be a delegate otherwise else isFun = !(r = isExpression.TypeSpecializationToken == DTokens.Delegate); if (r) { //TODO if (isFun) { // TypeTuple of the function parameter types. For C- and D-style variadic functions, only the non-variadic parameters are included. // For typesafe variadic functions, the ... is ignored. } else { // the function type of the delegate } } } else // Normal functions are also accepted as delegates { r = isExpression.TypeSpecializationToken == DTokens.Delegate && typeToCheck is MemberSymbol && ((DSymbol)typeToCheck).Definition is DMethod; //TODO: Alias handling, same as couple of lines above } break; case DTokens.Super: //TODO: Test this var dc = DResolver.SearchClassLikeAt(ctxt.ScopedBlock, isExpression.Location) as DClassLike; if (dc != null) { var udt = DResolver.ResolveBaseClasses(new ClassType(dc, dc, null), ctxt, true) as ClassType; if (r = udt.Base != null && ResultComparer.IsEqual(typeToCheck, udt.Base)) { var l = new List<AbstractType>(); if (udt.Base != null) l.Add(udt.Base); if (udt.BaseInterfaces != null && udt.BaseInterfaces.Length != 0) l.AddRange(udt.BaseInterfaces); res = new TypeTuple(isExpression, l); } } break; case DTokens.Const: case DTokens.Immutable: case DTokens.InOut: // TODO? case DTokens.Shared: if (r = typeToCheck.Modifier == isExpression.TypeSpecializationToken) res = typeToCheck; break; case DTokens.Return: // TODO: Test IStatement _u = null; var dm = DResolver.SearchBlockAt(ctxt.ScopedBlock, isExpression.Location, out _u) as DMethod; if (dm != null) { var retType_ = TypeDeclarationResolver.GetMethodReturnType(dm, ctxt); if (r = retType_ != null && ResultComparer.IsEqual(typeToCheck, retType_)) res = retType_; } break; } return new Tuple<bool, AbstractType>(r, res); }
public Expression <Func <TSource, TDestination> > CreateProjectionExpression <TDestination>() { var tuple = new TypeTuple(typeof(TSource), typeof(TDestination)); return((Expression <Func <TSource, TDestination> >) this.Config.CreateMapExpression(tuple, MapType.Projection)); }
public void CompileProjection(Type sourceType, Type destinationType) { var tuple = new TypeTuple(sourceType, destinationType); _projectionDict[tuple] = CreateProjectionCallExpression(tuple); }
/// <summary> /// Item1 - True, if isExpression returns true /// Item2 - If Item1 is true, it contains the type of the alias that is defined in the isExpression /// </summary> private Tuple <bool, AbstractType> evalIsExpression_EvalSpecToken(IsExpression isExpression, AbstractType typeToCheck, bool DoAliasHandling = false) { bool r = false; AbstractType res = null; switch (isExpression.TypeSpecializationToken) { /* * To handle semantic tokens like "return" or "super" it's just needed to * look into the current resolver context - * then, we'll be able to gather either the parent method or the currently scoped class definition. */ case DTokens.Struct: case DTokens.Union: case DTokens.Class: case DTokens.Interface: if (r = typeToCheck is UserDefinedType && ((TemplateIntermediateType)typeToCheck).Definition.ClassType == isExpression.TypeSpecializationToken) { res = typeToCheck; } break; case DTokens.Enum: if (!(typeToCheck is EnumType)) { break; } { var tr = (UserDefinedType)typeToCheck; r = true; res = tr.Base; } break; case DTokens.Function: case DTokens.Delegate: if (typeToCheck is DelegateType) { var isFun = false; var dgr = (DelegateType)typeToCheck; if (!dgr.IsFunctionLiteral) { r = isExpression.TypeSpecializationToken == ( (isFun = ((DelegateDeclaration)dgr.DeclarationOrExpressionBase).IsFunction) ? DTokens.Function : DTokens.Delegate); } // Must be a delegate otherwise else { isFun = !(r = isExpression.TypeSpecializationToken == DTokens.Delegate); } if (r) { //TODO if (isFun) { // TypeTuple of the function parameter types. For C- and D-style variadic functions, only the non-variadic parameters are included. // For typesafe variadic functions, the ... is ignored. } else { // the function type of the delegate } } } else // Normal functions are also accepted as delegates { r = isExpression.TypeSpecializationToken == DTokens.Delegate && typeToCheck is MemberSymbol && ((DSymbol)typeToCheck).Definition is DMethod; //TODO: Alias handling, same as couple of lines above } break; case DTokens.Super: //TODO: Test this var dc = DResolver.SearchClassLikeAt(ctxt.ScopedBlock, isExpression.Location) as DClassLike; if (dc != null) { var udt = DResolver.ResolveBaseClasses(new ClassType(dc, dc, null), ctxt, true) as ClassType; if (r = udt.Base != null && ResultComparer.IsEqual(typeToCheck, udt.Base)) { var l = new List <AbstractType>(); if (udt.Base != null) { l.Add(udt.Base); } if (udt.BaseInterfaces != null && udt.BaseInterfaces.Length != 0) { l.AddRange(udt.BaseInterfaces); } res = new TypeTuple(isExpression, l); } } break; case DTokens.Const: case DTokens.Immutable: case DTokens.InOut: // TODO? case DTokens.Shared: if (r = typeToCheck.Modifier == isExpression.TypeSpecializationToken) { res = typeToCheck; } break; case DTokens.Return: // TODO: Test IStatement _u = null; var dm = DResolver.SearchBlockAt(ctxt.ScopedBlock, isExpression.Location, out _u) as DMethod; if (dm != null) { var retType_ = TypeDeclarationResolver.GetMethodReturnType(dm, ctxt); if (r = retType_ != null && ResultComparer.IsEqual(typeToCheck, retType_)) { res = retType_; } } break; } return(new Tuple <bool, AbstractType>(r, res)); }
private static void GenerateMappers(MapperOptions opt) { using var dynamicContext = new AssemblyResolver(Path.GetFullPath(opt.Assembly)); var assembly = dynamicContext.Assembly; var config = TypeAdapterConfig.GlobalSettings; config.SelfContainedCodeGeneration = true; config.Scan(assembly); foreach (var type in assembly.GetTypes()) { if (!type.IsInterface) { continue; } var attr = type.GetCustomAttribute <MapperAttribute>(); if (attr == null) { continue; } Console.WriteLine($"Processing: {type.FullName}"); var definitions = new TypeDefinitions { Implements = new[] { type }, Namespace = opt.Namespace ?? type.Namespace, TypeName = attr.Name ?? GetImplName(type.Name), IsInternal = attr.IsInternal }; var translator = new ExpressionTranslator(definitions); var interfaces = type.GetAllInterfaces(); foreach (var @interface in interfaces) { foreach (var prop in @interface.GetProperties()) { if (!prop.PropertyType.IsGenericType) { continue; } if (prop.PropertyType.GetGenericTypeDefinition() != typeof(Expression <>)) { continue; } var propArgs = prop.PropertyType.GetGenericArguments()[0]; if (!propArgs.IsGenericType) { continue; } if (propArgs.GetGenericTypeDefinition() != typeof(Func <,>)) { continue; } var funcArgs = propArgs.GetGenericArguments(); var tuple = new TypeTuple(funcArgs[0], funcArgs[1]); var expr = config.CreateMapExpression(tuple, MapType.Projection); translator.VisitLambda(expr, ExpressionTranslator.LambdaType.PublicLambda, prop.Name); } } foreach (var @interface in interfaces) { foreach (var method in @interface.GetMethods()) { if (method.IsGenericMethod) { continue; } if (method.ReturnType == typeof(void)) { continue; } var methodArgs = method.GetParameters(); if (methodArgs.Length < 1 || methodArgs.Length > 2) { continue; } var tuple = new TypeTuple(methodArgs[0].ParameterType, method.ReturnType); var expr = config.CreateMapExpression(tuple, methodArgs.Length == 1 ? MapType.Map : MapType.MapToTarget); translator.VisitLambda(expr, ExpressionTranslator.LambdaType.PublicMethod, method.Name); } } var code = translator.ToString(); var path = Path.Combine(Path.GetFullPath(opt.Output), definitions.TypeName + ".g.cs"); WriteFile(code, path); } }
public MapRead mapRead(IEnumerable <IType> mapTypeArgs) { Debug.Assert(mapTypeArgs.Count() == mapType.typeParameters.Length); return(BasicMapRead.mapRead(mapType, TypeTuple.make(mapTypeArgs))); }
public static BasicMapWrite makeMapWrite( IEnumerable <IType> mapTypeArgumentsA, IEnumerable <IType> argumentTypesA, IType resultType) { var mapTypeArguments = TypeTuple.make(mapTypeArgumentsA); var argumentTypes = TypeTuple.make(argumentTypesA); Debug.Assert(mapTypeArguments != null); Debug.Assert(argumentTypes != null); Debug.Assert(argumentTypes.Count() > 1); var mapType = argumentTypes[0] as MapType; var sourceType = argumentTypes.Last(); Debug.Assert(mapType != null); Debug.Assert(mapType.domain.Count() == argumentTypes.Count() - 2); Debug.Assert(mapType.typeParameters.Count() == mapTypeArguments.Count()); var indexString = ""; foreach (var a in argumentTypes) { indexString += (indexString == "" ? "" : ",") + a.ToString(); } var indexTypes = TypeTuple.make(argumentTypes.Skip(1).Take(argumentTypes.Count() - 2)); BasicMapWrite result = null; bool foundInstance = instances.TryGetValue(indexString, out result); if (result != null) { if (!ReferenceEquals(resultType, result.resultType)) { foundInstance = false; } else { for (int i = 0; i < argumentTypes.Count(); i++) { if (!ReferenceEquals(argumentTypes[i], result.argumentTypes[i])) { foundInstance = false; break; } } } } if (!foundInstance) { result = new BasicMapWrite(mapType, indexTypes, sourceType, resultType, mapTypeArguments); Debug.Assert(indexString != null); Debug.Assert(instances != null); Debug.Assert(result != null); // instances.Add(indexString,result); instances[indexString] = result; } return(result); }
public Function getInstance() { return(getInstance(TypeTuple.make())); }
public static MapRead mu2ml(MapWrite mu) { var mlArgTypes = TypeTuple.make(mu.argumentTypes.Take(mu.argumentTypes.Count() - 1)); return(BasicMapRead.mapRead(mu.typeArguments.Skip(1).ToArray(), mlArgTypes, mu.argumentTypes.Last())); }
static void Main(string[] args) { IType Int = TypeSingleton.Integer, Bool = TypeSingleton.Boolean, Str = TypeSingleton.String, Func = new TypeFunction(new TypeTuple(), TypeSingleton.Void), Tuple = new TypeTuple(), Union = new TypeUnion(), Void = TypeSingleton.Void, Any = TypeSingleton.Any; Tokenizer Indentation = Tokenizers.Indentation, MathOperator = Tokenizers.Predicate("&|+-".Contains), MathOperator2 = Tokenizers.Predicate("*/%".Contains), ComparisonOperator = Tokenizers.Predicate("=<>".Contains), PrefixOperator = Tokenizers.Match("!"), String = Tokenizers.Quote('"', '"'), Integer = Tokenizers.Predicate(char.IsDigit), Symbol = Tokenizers.Predicate(char.IsLetterOrDigit); var compiler = new CompilerHelper(Indentation, MathOperator, MathOperator2, PrefixOperator, ComparisonOperator, String, Integer, Symbol); Func <string, Token> GetToken = compiler.GetToken; var SymbolParser = Tokens(Symbol); Parser <TypeName> TypeName; Parser <IEnumerable <TypeName> > TypeNames = null; Parser <(string, TypeName)> Variable; Parser <IEnumerable <(string, TypeName)> > Variables; TypeName = parser => new TypeName(SymbolParser.Invoke(parser), TypeNames(parser)); TypeNames = ListOf(GetToken("{"), TypeName, GetToken(","), GetToken("}")); Variable = parser => (SymbolParser.Invoke(parser), TypeName(parser)); Variables = ListOf(GetToken("["), Variable, GetToken(","), GetToken("]")); var expr = new ExprBuilders(new ExprWriters()); // Parser to Analyzer mappings compiler.ParserRules.SetRules( ParserRules.Rule(expr.CheckedCast, Prefix(GetToken("->"), TypeName), Expression), ParserRules.Rule(expr.Sequence, Sequence(Indentation, Expression)), ParserRules.Rule(expr.Function, Variables, Expression), ParserRules.Rule(expr.Function, ListOf(GetToken("{"), Variable, GetToken(","), GetToken("}")), Variables, Expression), ParserRules.Rule(expr.VariableAssign, Prefix(GetToken("let"), Suffix(SymbolParser, GetToken("="))), Expression), ParserRules.Rule(expr.Identity, Prefix(GetToken("("), Suffix(Expression, GetToken(")")))), ParserRules.Rule(expr.LiteralString, Tokens(String)), ParserRules.Rule(expr.LiteralInt, Tokens(Integer)), ParserRules.Rule(expr.LiteralBooleanTrue, GetToken("true")), ParserRules.Rule(expr.LiteralBooleanFalse, GetToken("false")), ParserRules.Rule(expr.If, Prefix(GetToken("if"), Expression), Expression, Prefix(GetToken("else"), Expression)), ParserRules.Rule(expr.This, GetToken("this")), ParserRules.Rule(expr.FunctionOperatorSingle, Tokens(PrefixOperator), Expression), ParserRules.Rule(expr.Variable, SymbolParser) ); compiler.ParserRules.SetInfixRules( ParserRules.Rule(expr.ContextVariable, weight: 6, Prefix(GetToken("."), SymbolParser)), ParserRules.Rule(expr.FunctionSetGenerics, weight: 5, TypeNames), ParserRules.Rule(expr.FunctionOperator, weight: 4, Tokens(MathOperator2), WeightedExpression(4)), ParserRules.Rule(expr.FunctionOperator, weight: 3, Tokens(MathOperator), WeightedExpression(3)), ParserRules.Rule(expr.FunctionOperator, weight: 2, Tokens(ComparisonOperator), WeightedExpression(2)), ParserRules.Rule(expr.BooleanAnd, weight: 1, Prefix(GetToken("and"), WeightedExpression(1))), ParserRules.Rule(expr.BooleanOr, weight: 1, Prefix(GetToken("or"), WeightedExpression(1))), ParserRules.Rule(expr.FunctionCall, weight: 6, ListOf(GetToken("("), Expression, GetToken(","), GetToken(")"))) ); compiler.AddType("int", Int); compiler.AddType("bool", Bool); compiler.AddType("string", Str); compiler.AddType("fun", Func); compiler.AddType("tuple", Tuple); compiler.AddType("union", Union); compiler.AddType("any", Any); compiler.AddType("void", Void); // Set of core functions. // TODO Optimize: compiler should 'unwrap' all short functions compiler.AddFunction("print", VMCommand.Print, Void, Any); compiler.AddFunction("<", VMCommand.CompareLessThan, Bool, Int, Int); compiler.AddFunction("+", VMCommand.MathAddition, Int, Int, Int); compiler.AddFunction("-", VMCommand.MathSubstraction, Int, Int, Int); compiler.AddFunction("*", VMCommand.MathMultiplication, Int, Int, Int); compiler.AddFunction("/", VMCommand.MathDivision, Int, Int, Int); compiler.AddFunction("!", VMCommand.BooleanNot, Bool, Bool); compiler.AddFunction("==", VMCommand.EqualInt, Bool, Bool, Bool); compiler.AddFunction("==", VMCommand.EqualInt, Bool, Int, Int); try { compiler.RunFile("Example"); } catch (CompilationException e) { Console.WriteLine("Compilation Error: " + e.Message); } }
public LambdaExpression CreateMapExpression <TDestination>() { var tuple = new TypeTuple(typeof(TSource), typeof(TDestination)); return(this.Config.CreateMapExpression(tuple, MapType.Map)); }
//////////////////////////////////////////////////////////////////////////////////// private Expression makeExpression(NAryExpr fae, bool old) { if (fae.Fun is TypeCoercion) { return(makeExpression(fae.Args[0], old)); } var arguments = new ExpressionList((from Expr e in fae.Args select makeExpression(e, old)).ToArray()); Function function; if (fae.Fun is MapSelect) { var typeArguments = new IType[fae.TypeParameters.FormalTypeParams.Count]; for (int i = 0; i < fae.TypeParameters.FormalTypeParams.Count; i++) { typeArguments[i] = makeType(fae.TypeParameters[fae.TypeParameters.FormalTypeParams[i]]); } var argumentTypes = TypeTuple.make(from a in arguments select a.type); function = BasicMapRead.mapRead( typeArguments, argumentTypes, makeType(fae.Type) ); } else if (fae.Fun is MapStore) { var typeArguments = new IType[fae.TypeParameters.FormalTypeParams.Count]; for (int i = 0; i < fae.TypeParameters.FormalTypeParams.Count; i++) { typeArguments[i] = makeType(fae.TypeParameters[fae.TypeParameters.FormalTypeParams[i]]); } function = BasicMapWrite.makeMapWrite(typeArguments, (from a in arguments select a.type).ToArray(), makeType(fae.ShallowType)); } else if (fae.Fun.FunctionName == "==" || fae.Fun.FunctionName == "!=") { if (arguments[0].type.isEquivalent(arguments[1].type)) { function = BFunction.eq(arguments[0].type); } else { Debug.Assert(!arguments[0].type.isGround || !arguments[1].type.isGround); function = BFunction.eq(arguments[0].type, arguments[1].type); } if (fae.Fun.FunctionName == "!=") { arguments = new ExpressionList( new BasicFAE( function, arguments ) ); function = scope.getFunction("!", TypeTuple.make()); } } else if (fae.Fun.FunctionName == "<:") { function = scope.getFunction(fae.Fun.FunctionName, TypeTuple.make(new[] { arguments[0].type })); } else if (fae.Fun.FunctionName == BFunctionTemplate.iteName) { function = scope.getFunction(fae.Fun.FunctionName, TypeTuple.make(new[] { arguments[1].type })); } else if (fae.Fun.FunctionName == @"-" && fae.Fun.ArgumentCount == 1) { arguments = new ExpressionList(new[] { new BasicLiteralExpression(IntegerValue.make(0)), arguments[0] }); function = scope.getFunction(@"-", TypeTuple.make()); } else { var typeArguments = TypeTuple.make((fae.TypeParameters == null) ? new IType[0] : (from ftp in fae.TypeParameters.FormalTypeParams select scope.typeFactory.makeTypeI(fae.TypeParameters[ftp], context))); function = scope.getFunction(fae.Fun.FunctionName, typeArguments); } var result = new BoogieFunctionApplicationExpression(fae, function, arguments); Debug.Assert(result.type.ToStringN() == makeType(fae.Type == null ? fae.ShallowType : fae.Type).ToStringN()); Debug.Assert(result != null); foreach (var fv in result.freeVariables) { Debug.Assert(context.lookupVariableByOwnName(fv.name) == fv); } foreach (var ftv in result.freeTypeVariables) { Debug.Assert(ReferenceEquals(context.lookupTypeVariable(ftv.name), ftv)); } return(result); }
public static ValueTuple Create(TypeTuple valueType, IEnumerable <ILanguageValue> value) { return(new ValueTuple(valueType, value)); }
protected ValueTuple(TypeTuple valueType, IEnumerable <ILanguageValue> value) { ValueTupleType = valueType; Value.AddRange(value); }