public static string GetOuterName(IDom item)
{
var name = "";
var itemToName = item;
var itemHasName = itemToName as IHasName;
if (itemHasName != null) name += itemHasName.Name;
if (!(itemToName is IStemMember || itemToName is ITypeMember)) return name;
var parent = itemToName.Parent;
do
{
// null is legal here because objects may be unattached
if (parent == null || parent is IRoot)
{
// at top of what we care about
break;
}
var parentHasName = parent as IHasName;
if (parentHasName != null)
{
var delimiter = ".";
if (itemToName is IType && parent is IType) delimiter = "+";
name = parentHasName.Name + (string.IsNullOrEmpty(name) ? "" : delimiter + name);
}
itemToName = parent;
parent = parent.Parent;
} while (parent != null);
return name;
}
public static string GetQualifiedName(IDom item)
{
if (item == null) throw new NotImplementedException();
var name = "";
var itemHasName = item as IHasName;
if (itemHasName != null) name += itemHasName.Name;
var parent = item.Parent;
do
{
// null is legal here because objects may be unattached
if (parent == null || parent is IRoot)
{
// at top of what we care about
break;
}
var parentHasName = parent as IHasName;
if (parentHasName != null)
{
var delimiter = ".";
name = parentHasName.Name + (string.IsNullOrEmpty(name) ? "" : delimiter + name);
}
item = parent;
parent = parent.Parent;
} while (parent != null);
return name;
}
//public static IEnumerable<T> CopyMembers<T>(IEnumerable<T> members)
//{
// var ret = new List<T>();
// if (members != null)
// {
// foreach (var member in members)
// {
// ret.Add(Copy(member));
// }
// }
// return ret;
//}
//public static T Copy<T>(T oldItem)
//{
// var type = oldItem.GetType();
// var constructors = type.GetTypeInfo()
// .DeclaredConstructors
// .Where(x => x.GetParameters().Count() == 1
// && type.IsAssignableFrom(x.GetParameters().First().ParameterType));
// Guardian.Assert.RDomHasOneCloneContructor(constructors, type);
// var constructor = constructors.FirstOrDefault();
// var newItem = constructor.Invoke(new object[] { oldItem });
// return (T)newItem;
//}
public static string GetNamespace(IDom item)
{
var ret = "";
if (item == null) { return ret; }
var itemAsNamespace = item as INamespace;
if (itemAsNamespace != null) { ret += itemAsNamespace.Name; }
if (item.Parent == null || item.Parent is IRoot) { return ret; }
var parentNamespace = GetNamespace(item.Parent);
if (!string.IsNullOrEmpty(parentNamespace))
{ ret = parentNamespace + (string.IsNullOrEmpty(ret) ? "" : "." + ret); }
return ret;
}
public RDomInvocationExpression(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
Initialize();
}
protected override IEnumerable <IDom> CreateListFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
return(InternalCreateFrom(syntaxNode, parent, model));
}
private void InitializeAccessModifiers(IHasAccessModifier itemHasAccessModifier, SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
if (itemHasAccessModifier == null)
{
return;
}
var itemAsHasSymbol = itemHasAccessModifier as IRoslynHasSymbol;
Guardian.Assert.IsNotNull(itemAsHasSymbol, nameof(itemAsHasSymbol));
var accessibility = itemAsHasSymbol.Symbol.DeclaredAccessibility;
itemHasAccessModifier.AccessModifier = Mappings.AccessModifierFromAccessibility(accessibility);
var tokens = syntaxNode.ChildTokens();
if (tokens.Any(x => x.CSharpKind() == SyntaxKind.PublicKeyword))
{
itemHasAccessModifier.DeclaredAccessModifier = AccessModifier.Public;
}
else if (tokens.Any(x => x.CSharpKind() == SyntaxKind.PrivateKeyword))
{
itemHasAccessModifier.DeclaredAccessModifier = AccessModifier.Private;
}
else if (tokens.Any(x => x.CSharpKind() == SyntaxKind.ProtectedKeyword) && tokens.Any(x => x.CSharpKind() == SyntaxKind.InternalKeyword))
{
itemHasAccessModifier.DeclaredAccessModifier = AccessModifier.ProtectedOrInternal;
}
else if (tokens.Any(x => x.CSharpKind() == SyntaxKind.ProtectedKeyword))
{
itemHasAccessModifier.DeclaredAccessModifier = AccessModifier.Protected;
}
else if (tokens.Any(x => x.CSharpKind() == SyntaxKind.InternalKeyword))
{
itemHasAccessModifier.DeclaredAccessModifier = AccessModifier.Internal;
}
else
{
itemHasAccessModifier.DeclaredAccessModifier = AccessModifier.None;
}
}
public void StoreWhitespaceForToken(IDom newItem, SyntaxToken token,
LanguagePart languagePart, LanguageElement languageElement)
{
triviaManager.StoreWhitespaceForToken(newItem, token, languagePart, languageElement);
}
private string GetFileName(IDom item)
{
var root = item.Ancestors.OfType<IRoot>().FirstOrDefault();
if (root != null)
{ return root.FilePath; }
else
{
var top = item.Ancestors.Last();
var node = top as SyntaxNode;
if (node == null)
{ return "<no file name>"; }
else
{ return node.SyntaxTree.FilePath; }
}
}
public virtual bool CanCreate(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
return(true);
}
protected virtual IEnumerable <IDom> CreateListFromInterim(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
return(CreateListFrom(syntaxNode, parent, model));
}
public RDomOtherExpression(IDom parent, string initialExpressionString,
string initialExpressionLanguage, ExpressionType expressionType)
: base(parent, initialExpressionString, initialExpressionLanguage, expressionType)
{
}
private LinePosition GetPosition(IDom item)
{
var node = item.RawItem as SyntaxNode;
if (node == null)
{ return default(LinePosition); }
else
{
var location = node.GetLocation();
var linePos = location.GetLineSpan().StartLinePosition;
return linePos;
}
}
private string GetOldCode(IDom item)
{
var node = item.RawItem as SyntaxNode;
if (node == null)
{ return "<no syntax node>"; }
else
{
return node.ToFullString();
}
}
private string GetNewCode(IDom item)
{
var ret = new List<string>();
var node = RDom.CSharp.GetSyntaxNode(item);
node = RDom.CSharp.Format(node);
return node.ToString();
// return RDomCSharp.Factory.BuildFormattedSyntax(item).ToString();
}
public RDomLiteralExpression(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
ExpressionType = ExpressionType.Literal;
}
public RDomOtherExpression(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
}
public RDomAttributeValue(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
}
public RDomVariableDeclaration(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
}
public abstract IEnumerable <SyntaxNode> BuildSyntax(IDom item);
public RDomLambdaSingleExpression(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
Initialize();
}
public RDomStructure(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model, MemberKind.Structure, StemMemberKind.Structure)
{
}
public RDomConstructor(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
Initialize();
}
public void StoreWhitespace(IDom newItem, SyntaxNode syntaxNode, LanguagePart languagePart, WhitespaceKindLookup whitespaceLookup)
{
triviaManager.StoreWhitespace(newItem, syntaxNode, languagePart, whitespaceLookup);
}
public bool AddOrMoveMember(IDom item)
{
return(_statements.AddOrMove(item));
}
public void StoreWhitespaceForFirstAndLastToken(IDom newItem, SyntaxNode node,
LanguagePart languagePart,
LanguageElement languageElement)
{
triviaManager.StoreWhitespaceForFirstAndLastToken(newItem, node, languagePart, languageElement);
}
public bool RemoveMember(IDom item)
{
return(_statements.Remove(item));
}
private IEnumerable <IAttribute> CreateFromList(AttributeListSyntax syntaxAsList, IDom parent, SemanticModel model)
{
var list = new List <IAttribute>();
foreach (var attSyntax in syntaxAsList.Attributes)
{
var attr = CreateFromItem(attSyntax, parent, model);
var rDomAttr = attr as IRoslynDom;
list.Add(attr);
}
return(list);
}
public bool InsertOrMoveMember(int index, IDom item)
{
return(_statements.InsertOrMove(index, item));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
return(BuildSyntax((IAttribute)item));
}
public RDomPublicAnnotation(IDom parent, SyntaxTrivia trivia, string name)
: base(parent, StemMemberKind.PublicAnnotation, MemberKind.PublicAnnotation, trivia, null)
{
_name = name;
}
public RDomStructuredDocumentation(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
}
private void InitializeOOTypeMember(IOOTypeMember itemAsOO, SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
if (itemAsOO == null)
{
return;
}
var itemAsDom = itemAsOO as IRoslynHasSymbol;
//itemAsOO.IsAbstract = itemAsDom.Symbol.IsAbstract;
itemAsOO.IsAbstract = syntaxNode.ChildTokens().Any(x => x.CSharpKind() == SyntaxKind.AbstractKeyword);
itemAsOO.IsVirtual = itemAsDom.Symbol.IsVirtual;
itemAsOO.IsOverride = itemAsDom.Symbol.IsOverride;
itemAsOO.IsSealed = itemAsDom.Symbol.IsSealed;
var itemAsCanBeNew = itemAsOO as ICanBeNew;
if (itemAsCanBeNew != null)
{
// See note on IsNew on interface before changing
itemAsCanBeNew.IsNew = syntaxNode.ChildTokens().Any(x => x.CSharpKind() == SyntaxKind.NewKeyword);
}
}
public RDomEmptyStatement(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
}
private void InitializeBaseList(IHasImplementedInterfaces itemAsT,
SyntaxNode node, IDom parent, SemanticModel model)
{
if (itemAsT == null)
{
return;
}
var symbol = ((IRoslynHasSymbol)itemAsT).Symbol as INamedTypeSymbol;
var interfaces = symbol.Interfaces;
var baseType = symbol.BaseType;
var baseList = node.ChildNodes().OfType <BaseListSyntax>().SingleOrDefault();
if (baseList != null)
{
IEnumerable <BaseTypeSyntax> types = baseList.Types.ToList();
StoreWhitespaceForToken(itemAsT, baseList.ColonToken, LanguagePart.Current, LanguageElement.BaseListPrefix);
if (baseType != null)
{
var baseName = baseType.ToString();
baseName = baseName.Contains(".")
? baseName.SubstringAfterLast(".")
: baseName;
if (node is ClassDeclarationSyntax && baseName == types.First().ToString())
{
var itemAsClass = itemAsT as RDomClass;
var syntax = types.First();
if (itemAsClass == null)
{
throw new InvalidOperationException();
}
var newBaseType = Corporation.Create(syntax, itemAsT, model).Single()
as IReferencedType;
itemAsClass.BaseType = newBaseType;
//StoreWhitespace(newBaseType, syntax,
// LanguagePart.Current, whitespaceLookupForImplementedInterfaces);
types = types.Skip(1);
}
}
foreach (var implementedInterfaceSyntax in types)
{
var newInterface = Corporation.Create(implementedInterfaceSyntax, itemAsT, model).Single()
as IReferencedType;
//StoreWhitespace(newInterface, implementedInterfaceSyntax,
// LanguagePart.Current, whitespaceLookupForImplementedInterfaces);
var whitespace2 = newInterface.Whitespace2Set[LanguageElement.Identifier];
if (string.IsNullOrEmpty(whitespace2.LeadingWhitespace))
{
var prevNodeOrToken = implementedInterfaceSyntax.Parent
.ChildNodesAndTokens()
.PreviousSiblings(implementedInterfaceSyntax)
.LastOrDefault();
var sepKind = whitespaceLookupForImplementedInterfaces.Lookup(LanguageElement.Separator);
if (prevNodeOrToken.CSharpKind() == sepKind)
{
var commaToken = prevNodeOrToken.AsToken();
whitespace2.LeadingWhitespace = commaToken.TrailingTrivia.ToString();
}
}
itemAsT.ImplementedInterfaces.AddOrMove(newInterface);
}
}
}
public RDomField(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
}
private void InitializeTypeParameters(IHasTypeParameters itemAsT, SyntaxNode node, IDom parent, SemanticModel model)
{
if (itemAsT == null)
{
return;
}
//var symbol = ((IRoslynHasSymbol)itemAsT).Symbol as INamedTypeSymbol;
//var interfaces = symbol.Interfaces;
var typeParameterList = node.ChildNodes().OfType <TypeParameterListSyntax>().SingleOrDefault();
if (typeParameterList == null)
{
return;
}
var typeParameters = typeParameterList.Parameters;
foreach (var p in typeParameters)
{
var newBase = Corporation.Create(p, itemAsT, model).Single()
as ITypeParameter;
itemAsT.TypeParameters.AddOrMove(newBase);
}
}
protected virtual IEnumerable <IDom> CreateListFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
return(new IDom[] { CreateItemFrom(syntaxNode, parent, model) });
}
private void InitializeStructuredDocumentation(IHasStructuredDocumentation item, SyntaxNode syntaxNode, IDom parent, SemanticModel model, OutputContext context)
{
if (item == null)
{
return;
}
var structuredDocumentation = GetStructuredDocumenation(syntaxNode, item, model, context).FirstOrDefault();
if (structuredDocumentation != null)
{
item.StructuredDocumentation = structuredDocumentation;
item.Description = structuredDocumentation.Description;
}
}
protected virtual IDom CreateItemFrom(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
// This can't be tested, but making it abstract means we have untestable code in seven derived classes.
Guardian.Assert.NeitherCreateFromNorListOverridden(this.GetType(), syntaxNode);
return(null);
}
//public IEnumerable<IDetail> GetDetail<T, TSyntax>(TSyntax syntaxNode, T newItem, SemanticModel model, OutputContext context)
// where T : class, IDom
// where TSyntax : SyntaxNode
//{
// //return Corporation.Create<IDetail>(syntaxNode, newItem, model);
// var ret = new List<IDetail>();
// // The parent of the syntax is the next item. The parent of the region is the thing it's attached to
// var parent = newItem.Parent;
// if (!syntaxNode.HasLeadingTrivia) return ret;
// var triviaList = syntaxNode.GetLeadingTrivia();
// var lastWasComment = false;
// var precedingTrivia = new List<SyntaxTrivia>();
// foreach (var trivia in triviaList)
// {
// // This is ugly, but we assume comments stand on their own lines.
// var skip = (lastWasComment && trivia.CSharpKind() == SyntaxKind.EndOfLineTrivia);
// lastWasComment = false;
// if (!skip)
// {
// switch (trivia.CSharpKind())
// {
// case SyntaxKind.EndOfLineTrivia:
// // TODO: Consider whether leading WS on a vert whitespace matters
// ret.Add(new RDomVerticalWhitespace(trivia, 1, false));
// break;
// case SyntaxKind.SingleLineCommentTrivia:
// case SyntaxKind.MultiLineCommentTrivia:
// ret.Add(MakeComment(syntaxNode, precedingTrivia, trivia, parent, context));
// lastWasComment = true;
// break;
// case SyntaxKind.RegionDirectiveTrivia:
// case SyntaxKind.EndRegionDirectiveTrivia:
// ret.Add(context.Corporation.GetTriviaFactory<IDetail>().CreateFrom(trivia, parent, context) as IDetail);
// break;
// }
// }
// precedingTrivia.Add(trivia);
// }
// return ret;
//}
private IDetail MakeComment(SyntaxNode syntaxNode, List <SyntaxTrivia> precedingTrivia, SyntaxTrivia trivia, IDom parent, OutputContext context)
{
var publicAnnotation = context.Corporation.GetTriviaFactory <IPublicAnnotation>().CreateFrom(trivia, parent, context) as IPublicAnnotation;
if (publicAnnotation != null)
{
return(publicAnnotation);
}
var newComment = context.Corporation.GetTriviaFactory <IDetail>().CreateFrom(trivia, parent, context) as IComment;
return(newComment);
}
public virtual bool CanCreateSpecialExplicit <TSpecial>(SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
return(true);
}
public void InitializeStatements(IStatementBlock itemAsStatement, SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
if (syntaxNode == null)
{
return;
}
if (itemAsStatement == null)
{
return;
}
var blockSyntax = syntaxNode as BlockSyntax;
if (blockSyntax != null)
{
itemAsStatement.StatementsAll.CreateAndAdd(blockSyntax.Statements, x => Corporation.Create(x, parent, model).Cast <IStatementAndDetail>());
itemAsStatement.HasBlock = true;
return;
}
var statementSyntax = syntaxNode as StatementSyntax;
if (statementSyntax != null)
{
var statements = Corporation.Create(statementSyntax, parent, model).OfType <IStatementAndDetail>();
if (statements.Count() > 1)
{
throw new NotImplementedException();
}
var statement = statements.First();
var statementAsBlockStatement = statement as IBlockStatement;
if (statementAsBlockStatement != null)
{
itemAsStatement.HasBlock = true;
foreach (var st in statementAsBlockStatement.Statements)
{
itemAsStatement.StatementsAll.AddOrMove(st);
}
}
else
{
itemAsStatement.StatementsAll.AddOrMove(statement);
}
}
}
private static bool IsInRDomClass(IDom prop)
{
if (prop.Parent == null || !(prop.Parent is IClass)) return false;
var parent = (IClass)prop.Parent;
if (!parent.Name.StartsWith("RDom")) return false;
if (parent.BaseType == null || !(parent.BaseType.Name.StartsWith("RDom"))) return false;
return true;
}
public RDomLiteralExpression(SyntaxNode rawItem, IDom parent, SemanticModel model)
: base(rawItem, parent, model)
{
ExpressionType = ExpressionType.Literal;
}
