private void MemberWhitespace(RDomEnumMember newItem, EnumMemberDeclarationSyntax syntax) { //CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetFirstToken(), LanguagePart.Current, LanguageElement.EnumValueFirstToken); //CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetLastToken(), LanguagePart.Current, LanguageElement.EnumValueLastToken); if (syntax.EqualsValue != null) { CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.EqualsValue.Value.GetLastToken(), LanguagePart.Current, LanguageElement.Expression); CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.EqualsValue.EqualsToken, LanguagePart.Current, LanguageElement.EnumValueAssignOperator); } CreateFromWorker.StoreListMemberWhitespace(syntax, WhitespaceLookup.Lookup(LanguageElement.EnumValueSeparator), LanguageElement.Identifier, newItem); //var prevNodeOrToken = syntax.Parent // .ChildNodesAndTokens() // .PreviousSiblings(syntax) // .LastOrDefault(); //var sepKind = WhitespaceLookup.Lookup(LanguageElement.EnumValueSeparator); //if (prevNodeOrToken.CSharpKind() == sepKind) //{ // var commaToken = prevNodeOrToken.AsToken(); // var whitespace2 = newItem.Whitespace2Set[LanguageElement.Identifier]; // var newLeadingWhitespace = commaToken.TrailingTrivia.ToString();; // if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace) // || newLeadingWhitespace.EndsWith("\r\n")) // { whitespace2.LeadingWhitespace = newLeadingWhitespace // + whitespace2.LeadingWhitespace; } //} }
private IEnumerable <IMisc> CreateFromVariableDeclaration( VariableDeclarationSyntax syntax, SyntaxNode syntaxNode, IDom parent, SemanticModel model, Func <SyntaxNode, IDom, SemanticModel, RDomBaseVariable> makeNewDelegate) { var list = new List <IMisc>(); var declarators = syntax.Variables.OfType <VariableDeclaratorSyntax>(); foreach (var decl in declarators) { var newItem = SetupNewVariable(VariableKind.Local, makeNewDelegate(decl, parent, model), syntax.Type, decl, parent, model); var rDomItem = newItem as IRoslynDom; list.Add(newItem); CreateFromWorker.StoreWhitespace(newItem, decl, LanguagePart.Current, WhitespaceLookup); if (decl.Initializer != null) { var equalsClause = decl.Initializer; newItem.Initializer = OutputContext.Corporation.CreateSpecial <IExpression>(equalsClause.Value, newItem, model).FirstOrDefault(); //newItem.Initializer = (IExpression)OutputContext.Corporation.Create(equalsClause.Value, newItem, model).FirstOrDefault(); CreateFromWorker.StandardInitialize(newItem.Initializer, decl, parent, model, OutputContext); CreateFromWorker.StoreWhitespaceForToken(newItem, decl.Initializer.EqualsToken, LanguagePart.Current, LanguageElement.EqualsAssignmentOperator); CreateFromWorker.StoreWhitespaceForFirstAndLastToken(newItem, decl.Initializer, LanguagePart.Current, LanguageElement.Expression); } } return(list); }
private void MemberWhitespace(RDomParameter newItem, ParameterSyntax syntax) { CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetFirstToken(), LanguagePart.Current, LanguageElement.ParameterFirstToken); CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetLastToken(), LanguagePart.Current, LanguageElement.ParameterLastToken); CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup); if (syntax.Default != null) { CreateFromWorker.StoreWhitespace(newItem, syntax.Default, LanguagePart.Current, WhitespaceLookup); //CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.Default.Value.GetLastToken(), LanguagePart.Current, LanguageElement.Identifier); //CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.Default.EqualsToken, LanguagePart.Current, LanguageElement.ParameterDefaultAssignOperator); } CreateFromWorker.StoreListMemberWhitespace(syntax, WhitespaceLookup.Lookup(LanguageElement.ParameterSeparator), LanguageElement.ParameterFirstToken, newItem); //var prevNodeOrToken = syntax.Parent // .ChildNodesAndTokens() // .PreviousSiblings(syntax) // .LastOrDefault(); //var sepKind = WhitespaceLookup.Lookup(LanguageElement.ParameterSeparator); //if (prevNodeOrToken.CSharpKind() == sepKind) //{ // var commaToken = prevNodeOrToken.AsToken(); // var whitespace2 = newItem.Whitespace2Set[LanguageElement.ParameterFirstToken]; // if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace)) // { whitespace2.LeadingWhitespace = commaToken.TrailingTrivia.ToString(); } //} }
private void StoreWhitespaceForNamed(RDomAttributeValue newItem, AttributeArgumentSyntax syntax, SyntaxToken identifier, SyntaxToken op) { CreateFromWorker.StoreWhitespaceForToken(newItem, identifier, LanguagePart.Current, LanguageElement.AttributeValueName); CreateFromWorker.StoreWhitespaceForToken(newItem, op, LanguagePart.Current, LanguageElement.AttributeValueEqualsOrColon); var lastToken = syntax.GetLastToken(); CreateFromWorker.StoreWhitespaceForToken(newItem, lastToken, LanguagePart.Current, LanguageElement.AttributeValueValue); }
private void MemberWhitespace(RDomArgument newItem, ArgumentSyntax syntax) { CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetFirstToken(), LanguagePart.Current, LanguageElement.ParameterFirstToken); CreateFromWorker.StoreWhitespaceForToken(newItem, syntax.GetLastToken(), LanguagePart.Current, LanguageElement.ParameterLastToken); CreateFromWorker.StoreWhitespace(newItem, syntax, LanguagePart.Current, WhitespaceLookup); CreateFromWorker.StoreListMemberWhitespace(syntax, WhitespaceLookup.Lookup(LanguageElement.ParameterSeparator), LanguageElement.ParameterFirstToken, newItem); }
private void StoreWhitespace(TypeSyntax typeSyntax, RDomReferencedType newItem) { //CreateFromWorker.StoreWhitespace(newItem, typeSyntax, LanguagePart.Current, whitespaceLookup); var identifierToken = typeSyntax.ChildTokens() .Where(x => x.CSharpKind() == SyntaxKind.IdentifierToken) .FirstOrDefault(); CreateFromWorker.StoreWhitespaceForToken(newItem, identifierToken, LanguagePart.Current, LanguageElement.Identifier); var firstToken = typeSyntax.GetFirstToken(); var lastToken = typeSyntax.GetLastToken(); if (identifierToken != firstToken) { CreateFromWorker.StoreWhitespaceForToken(newItem, firstToken, LanguagePart.Current, LanguageElement.FirstToken); } if (identifierToken != lastToken && lastToken.CSharpKind() != SyntaxKind.GreaterThanToken) { CreateFromWorker.StoreWhitespaceForToken(newItem, lastToken, LanguagePart.Current, LanguageElement.LastToken); } var typeArgumentList = typeSyntax.ChildNodes() .OfType <TypeArgumentListSyntax>() .FirstOrDefault(); if (typeArgumentList != null) { CreateFromWorker.StoreWhitespaceForToken(newItem, typeArgumentList.LessThanToken, LanguagePart.Current, LanguageElement.TypeParameterStartDelimiter); CreateFromWorker.StoreWhitespaceForToken(newItem, typeArgumentList.GreaterThanToken, LanguagePart.Current, LanguageElement.TypeParameterEndDelimiter); } //// This is ugly, but there are so many uses for this class I had //// trouble with the generalized StoreWhitespace doubling some //// whitespace. //var openTypeParam = typeSyntax.ChildTokens() // .Where(x => x.CSharpKind() == SyntaxKind.LessThanToken) // .FirstOrDefault(); //CreateFromWorker.StoreWhitespaceForToken(newItem, openTypeParam, LanguagePart.Current, LanguageElement.TypeParameterStartDelimiter); //var closeTypeParam = typeSyntax.ChildTokens() // .Where(x => x.CSharpKind() == SyntaxKind.GreaterThanToken) // .FirstOrDefault(); //CreateFromWorker.StoreWhitespaceForToken(newItem, closeTypeParam, LanguagePart.Current, LanguageElement.TypeParameterEndDelimiter); }
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); }
private RDomIfStatement CreateCollapsing(IfStatementSyntax syntax, IDom parent, SemanticModel model) { // You can't use descendants here becuase it is a very specific pattern var newItem = new RDomIfStatement(syntax, parent, model); UpdateItem(newItem, syntax.Statement, syntax.Condition, syntax, parent, model); var currentSyntax = syntax; IElseBaseStatement lastItem = newItem; while (currentSyntax != null) { if (currentSyntax.Else == null) // We're done { break; } var elseAsIf = currentSyntax.Else.Statement as IfStatementSyntax; if (elseAsIf != null) { var newElse = new RDomElseIfStatement(elseAsIf, newItem, model); UpdateItem(newElse, elseAsIf.Statement, elseAsIf.Condition, elseAsIf, newItem, model); CreateFromWorker.StoreWhitespaceForToken(newElse, currentSyntax.Else.ElseKeyword, LanguagePart.Current, LanguageElement.ElseKeyword); newItem.Elses.AddOrMove(newElse); lastItem = newElse; currentSyntax = elseAsIf; } else // At terminus, add else and we're done { var newElse = new RDomElseStatement(currentSyntax.Else, newItem, model); UpdateItem(newElse, currentSyntax.Else.Statement, null, currentSyntax.Else, newItem, model); CreateFromWorker.StoreWhitespaceForToken(newElse, currentSyntax.Else.ElseKeyword, LanguagePart.Current, LanguageElement.ElseKeyword); newItem.Elses.AddOrMove(newElse); break; } } return(newItem); }
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); }