protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model) { var syntax = syntaxNode as ConstructorDeclarationSyntax; var newItem = new RDomConstructor(syntaxNode, parent, model); CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext); CreateFromWorker.InitializeStatements(newItem, syntax.Body, newItem, model); CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup); CreateFromWorker.StoreWhitespace(newItem, syntax.Initializer, LanguagePart.Initializer, WhitespaceLookup); CreateFromWorker.StoreWhitespace(newItem, syntax.Body, LanguagePart.Current, WhitespaceLookup); CreateFromWorker.StoreWhitespace(newItem, syntax.ParameterList, LanguagePart.Current, WhitespaceLookup); newItem.Name = newItem.TypedSymbol.Name; //newItem.AccessModifier = RoslynUtilities.GetAccessibilityFromSymbol(newItem.Symbol); //newItem.IsStatic = newItem.Symbol.IsStatic; newItem.Parameters.CreateAndAdd(syntax, x => x.ParameterList.Parameters, x => OutputContext.Corporation.Create(x, newItem, model).Cast <IParameter>()); //var parameters = ListUtilities.MakeList(syntax, x => x.ParameterList.Parameters, x => Corporation.Create(x, newItem, model)) // .OfType<IParameter>(); //newItem.Parameters.AddOrMoveRange(parameters); if (syntax.Initializer == null) { newItem.ConstructorInitializerType = ConstructorInitializerType.None; } else { var initializerSyntax = syntax.Initializer; if (initializerSyntax.ThisOrBaseKeyword.ToString() == "this") { newItem.ConstructorInitializerType = ConstructorInitializerType.This; } else { newItem.ConstructorInitializerType = ConstructorInitializerType.Base; } CreateFromWorker.StoreWhitespace(newItem, initializerSyntax.ArgumentList, LanguagePart.Initializer, WhitespaceLookup); foreach (var arg in initializerSyntax.ArgumentList.Arguments) { var newArg = new RDomArgument(arg, newItem, model); // TODO: Named paramters and align this with the invocation factory newArg.ValueExpression = OutputContext.Corporation.CreateSpecial <IExpression>(arg.Expression, newItem, model).FirstOrDefault(); CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newArg, arg, LanguagePart.Current, LanguageElement.ConstructorInitializerArgument); CreateFromWorker.StoreListMemberWhitespace(arg, SyntaxKind.CommaToken, LanguageElement.ConstructorInitializerArgument, newArg); newItem.InitializationArguments.AddOrMove(newArg); } } return(newItem); }
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model) { var syntax = syntaxNode as ExpressionStatementSyntax; var newItem = new RDomInvocationStatement(syntaxNode, parent, model); CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext); CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.Expression); var expression = syntax.Expression; //newItem.Invocation = (IInvocationExpression)OutputContext.Corporation.Create<IExpression>(expression, newItem, model).FirstOrDefault(); newItem.Invocation = OutputContext.Corporation.Create(expression, newItem, model).FirstOrDefault() as IInvocationExpression; return(newItem); }
protected override IEnumerable <IDom> CreateListFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model) { var list = new List <ITypeMember>(); //var fieldPublicAnnotations = CreateFromWorker.GetPublicAnnotations(syntaxNode, parent, model); var rawField = syntaxNode as FieldDeclarationSyntax; var declarators = rawField.Declaration.Variables.OfType <VariableDeclaratorSyntax>(); foreach (var decl in declarators) { var newItem = new RDomField(decl, parent, model); list.Add(newItem); CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext); CreateFromWorker.StoreWhitespace(newItem, syntaxNode, LanguagePart.Current, WhitespaceLookup); CreateFromWorker.StoreWhitespace(newItem, decl, LanguagePart.Current, WhitespaceLookup); newItem.Name = newItem.TypedSymbol.Name; if (decl.Initializer != null) { CreateFromWorker.StoreWhitespaceForToken(newItem, decl.Initializer.EqualsToken, LanguagePart.Current, LanguageElement.EqualsAssignmentOperator); CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, decl.Initializer, LanguagePart.Current, LanguageElement.Expression); newItem.Initializer = OutputContext.Corporation.CreateSpecial <IExpression>(decl.Initializer.Value, newItem, model).FirstOrDefault(); } var returnType = OutputContext.Corporation .Create(rawField.Declaration.Type, newItem, model) .FirstOrDefault() as IReferencedType; newItem.ReturnType = returnType; var fieldSymbol = newItem.Symbol as IFieldSymbol; newItem.IsStatic = fieldSymbol.IsStatic; newItem.IsVolatile = fieldSymbol.IsVolatile; newItem.IsReadOnly = fieldSymbol.IsReadOnly; newItem.IsConstant = fieldSymbol.HasConstantValue; // See note on IsNew on interface before changing newItem.IsNew = rawField.Modifiers.Any(x => x.Kind() == SyntaxKind.NewKeyword); //newItem.PublicAnnotations.Add(fieldPublicAnnotations); } return(list); }
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model) { var syntax = syntaxNode as ArgumentSyntax; var newItem = new RDomArgument(syntax, parent, model); CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext); newItem.ValueExpression = OutputContext.Corporation.CreateSpecial <IExpression>(syntax.Expression, newItem, model).FirstOrDefault(); newItem.IsOut = syntax.ChildTokens().Any(x => x.Kind() == SyntaxKind.OutKeyword); newItem.IsRef = syntax.ChildTokens().Any(x => x.Kind() == SyntaxKind.RefKeyword); if (syntax.NameColon != null) { newItem.Name = syntax.NameColon.Name.ToString(); } CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.OutModifier); CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.RefModifier); MemberWhitespace(newItem, syntax); return(newItem); }
private void StoreConstructorConstraint(ConstructorConstraintSyntax syntax, RDomTypeParameter newItem) { newItem.HasConstructorConstraint = true; CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, syntax, LanguagePart.Current, LanguageElement.ConstructorConstraint); CreateFromWorker.StoreListMemberWhitespace(syntax, SyntaxKind.CommaToken, LanguageElement.ConstructorConstraint, newItem); //var whitespace2 = newItem.Whitespace2Set[LanguageElement.ConstructorConstraint]; //if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace)) //{ // var prevNodeOrToken = syntax.Parent // .ChildNodesAndTokens() // .PreviousSiblings(syntax) // .LastOrDefault(); // var sepKind = SyntaxKind.CommaToken; // if (prevNodeOrToken.Kind() == sepKind) // { // var commaToken = prevNodeOrToken.AsToken(); // whitespace2.LeadingWhitespace = commaToken.TrailingTrivia.ToString(); // } //} }
protected override IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model) { // TODO: Why not cast immediately to BinaryExpression? var syntax = syntaxNode as ExpressionStatementSyntax; var newItem = new RDomAssignmentStatement(syntaxNode, parent, model); CreateFromWorker.StandardInitialize(newItem, syntaxNode, parent, model, OutputContext); CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup); CreateFromWorker.StoreWhitespace(newItem, syntax.Expression, LanguagePart.Current, WhitespaceLookup); var binary = syntax.Expression as AssignmentExpressionSyntax; Guardian.Assert.IsNotNull(binary, nameof(binary)); var left = binary.Left as ExpressionSyntax; CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, left, LanguagePart.Current, LanguageElement.LeftExpression); newItem.Left = OutputContext.Corporation.CreateSpecial <IExpression>(left, newItem, model).FirstOrDefault(); // Previously tested for identifier here, but can also be SimpleMemberAccess and ElementAccess expressions // not currently seeing value in testing for the type. Fix #46 // Also changed Name to Left and string to expression var right = binary.Right; var expression = right as ExpressionSyntax; CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, expression, LanguagePart.Current, LanguageElement.Expression); Guardian.Assert.IsNotNull(expression, nameof(expression)); newItem.Expression = OutputContext.Corporation.CreateSpecial <IExpression>(expression, newItem, model).FirstOrDefault(); CreateFromWorker.StoreWhitespaceForToken(newItem, binary.OperatorToken, LanguagePart.Current, LanguageElement.AssignmentOperator); newItem.Operator = Mappings.AssignmentOperatorFromCSharpKind(binary.CSharpKind()); return(newItem); }