public static TypeSyntax GetTypeNameSyntax(this TypeMember type) { var clrBinding = type.Bindings.FirstOrDefault <System.Type>(); if (clrBinding != null) { if (clrBinding.IsArray) { var elementTypeSyntax = GetTypeNameSyntax(type.UnderlyingType); return(SyntaxFactory.ArrayType(elementTypeSyntax) .WithRankSpecifiers(SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression()))))); } if (_s_keywordPerType.TryGetValue(clrBinding, out SyntaxKind keyword)) { return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(keyword))); } if (IsNullableValueType(clrBinding.GetTypeInfo(), out Type underlyingValueType)) { var context = CodeGeneratorContext.GetContextOrThrow(); return(SyntaxFactory.NullableType(GetTypeNameSyntax(context.FindType(underlyingValueType)))); } } return(GetTypeFullNameSyntax(type)); }
private void FlushImportDirective() { var context = CodeGeneratorContext.GetContextOrThrow(); var module = context.LookupStateOrThrow <ModuleMember>(); module.Imports.Add(Directive); }
protected void GenerateEventHandlerActionKey(IdentifierName eventName, IReadOnlyList <IFunctionContext> handlerList) { KEY(GetEventActionKeyName(eventName), LAMBDA(@model => DO.RETURN(ASYNC.LAMBDA((@state, @actions) => { LOCAL("newModel", out var @newModel, USE("Object").DOT("assign").INVOKE(INITOBJECT(), @model)); var modelMemberAccessRewriter = new ModelMemberAccessRewriter(Metadata.Page, @newModel); var apiMemberAccessRewriter = new BackendApiProxyAccessRewriter(Metadata.Page); var actionBlock = CodeGeneratorContext.GetContextOrThrow().GetCurrentBlock(); foreach (var handler in handlerList) { var rewrittenHandlerBody = apiMemberAccessRewriter.RewriteBlockStatement( modelMemberAccessRewriter.RewriteBlockStatement(handler.Body)); foreach (var statement in rewrittenHandlerBody.Statements) { actionBlock.AppendStatement(statement); } } actions.DOT("replaceModel").INVOKE(@newModel); })) )); }
public void ELSE(Action body) { _statement.ElseBlock = new BlockStatement(); using (CodeGeneratorContext.GetContextOrThrow().PushState(_statement.ElseBlock)) { body?.Invoke(); } }
public FluentElse THEN(Action body) { _statement.ThenBlock = new BlockStatement(); var context = CodeGeneratorContext.GetContextOrThrow(); using (context.PushState(new BlockContext(_statement.ThenBlock))) { body?.Invoke(); } return(new FluentElse(_statement)); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- private static bool IsTypeNamespaceImported(TypeMember type) { var importContext = CodeGeneratorContext.GetContextOrThrow().LookupStateOrThrow <ImportContext>(); if (importContext.IsTypeImported(type)) { return(true); } if (type.IsGenericType && type.GenericTypeDefinition != null) { return(importContext.IsTypeImported(type.GenericTypeDefinition)); } return(false); }
public SyntaxTree EmitSyntax() { DetermineNamespaceImports(GetReferencedTypes(), out var usingSyntaxList, out var importContext); using (CodeGeneratorContext.GetContextOrThrow().PushState(importContext)) { var typeSyntax = TypeSyntaxEmitter.GetSyntax(_type); var unitSyntax = SyntaxFactory.CompilationUnit() .WithUsings(SyntaxFactory.List(usingSyntaxList)) .WithMembers( SyntaxFactory.SingletonList <MemberDeclarationSyntax>( SyntaxFactory.NamespaceDeclaration(CreateQualifiedNameSyntax(_type.Namespace.Split('.'))) .WithMembers(SyntaxFactory.SingletonList(typeSyntax)))) .NormalizeWhitespace(); return(unitSyntax.SyntaxTree); } }
public FluentMember(bool?isAsync = null, bool?isReadOnly = null, bool?isDefaultExport = null) { var traits = CodeGeneratorContext.GetContextOrThrow().PeekStateOrThrow <MemberTraitsContext>(); if (isAsync.HasValue) { traits.IsAsync = isAsync.Value; } if (isReadOnly.HasValue) { traits.IsReadOnly = isReadOnly.Value; } if (isDefaultExport.HasValue) { traits.IsDefaultExport = isDefaultExport.Value; } }
public static TypeMember BuildTypeMember(TypeMemberKind typeKind, IdentifierName name, Action body) { var context = CodeGeneratorContext.GetContextOrThrow(); var module = context.TryLookupState <ModuleMember>(); var namespaceContext = context.TryLookupState <NamespaceContext>(); var traits = context.PopStateOrThrow <MemberTraitsContext>(); var containingType = context.TryLookupState <TypeMember>(); var type = new TypeMember(); type.Name = name; type.Namespace = namespaceContext?.Name; type.TypeKind = typeKind; type.DeclaringModule = module; type.DeclaringType = containingType; type.Modifier = traits.Modifier; type.Visibility = traits.Visibility; type.IsDefaultExport = traits.IsDefaultExport; if (containingType != null) { containingType.Members.Add(type); } context.AddGeneratedMember(type, isTopLevel: containingType == null); if (module != null) { module.Members.Add(type); } using (context.PushState(type)) { body?.Invoke(); } return(type); }
public FluentModifier(MemberModifier modifier) { CodeGeneratorContext.GetContextOrThrow().PeekStateOrThrow <MemberTraitsContext>().Modifier = modifier; }
public FluentVisibility(MemberVisibility visibility) { CodeGeneratorContext.GetContextOrThrow().PushState(new MemberTraitsContext(visibility)); }
public static BlockContext GetBlockOrThrow() { return(CodeGeneratorContext.GetContextOrThrow().GetCurrentBlock()); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public static ExpressionSyntax GetLiteralSyntax(object value) { if (value is ConstantExpression expression) { value = expression.Value; } if (value == null) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)); } else if (value is int intValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(intValue))); } else if (value is float floatValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(floatValue))); } else if (value is long longValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(longValue))); } else if (value is decimal decimalValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(decimalValue))); } else if (value is uint uintValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(uintValue))); } else if (value is double doubleValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(doubleValue))); } else if (value is ulong ulongValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(ulongValue))); } else if (value is string stringValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(stringValue))); } else if (value is char charValue) { return(SyntaxFactory.LiteralExpression(SyntaxKind.CharacterLiteralExpression, SyntaxFactory.Literal(charValue))); } else if (value is bool boolValue) { return(SyntaxFactory.LiteralExpression(boolValue ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression)); } else if (value is Type typeValue) { var context = CodeGeneratorContext.GetContextOrThrow(); return(SyntaxFactory.TypeOfExpression(GetTypeNameSyntax(context.FindType(typeValue)))); } else if (value is TypeMember typeMember) { return(SyntaxFactory.TypeOfExpression(GetTypeNameSyntax(typeMember))); } throw new NotSupportedException($"Literals of type {value.GetType().Name} are not supported"); }