public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
currentNamepace = namespaceDeclaration.Name;
base.VisitNamespaceDeclaration(namespaceDeclaration, data);
currentNamepace = string.Empty;
return null;
}
NamespaceDeclaration CreateNamespace(DependencyRelation relation, NamespaceDeclaration originalNamespace)
{
var ns = new NamespaceDeclaration(originalNamespace.Name);
ns.Children.AddRange(originalNamespace.Children.OfType<UsingDeclaration>());
ns.Children.Add(CreatePartialClass(relation));
return ns;
}
NamespaceDeclaration CreateNamespace(ValueObjectDescriptor valueObject, NamespaceDeclaration originalNamespace)
{
var ns = new NamespaceDeclaration(originalNamespace.Name);
ns.Children.AddRange(originalNamespace.Children.OfType<UsingDeclaration>());
ns.Children.Add(CreatePartialClass(valueObject));
return ns;
}
public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
{
base.VisitCompilationUnit(compilationUnit, data);
if (!string.IsNullOrEmpty(NamespacePrefixToAdd)) {
for (int i = 0; i < compilationUnit.Children.Count; i++) {
NamespaceDeclaration ns = compilationUnit.Children[i] as NamespaceDeclaration;
if (ns != null) {
ns.Name = NamespacePrefixToAdd + "." + ns.Name;
}
if (compilationUnit.Children[i] is TypeDeclaration || compilationUnit.Children[i] is DelegateDeclaration) {
ns = new NamespaceDeclaration(NamespacePrefixToAdd);
ns.AddChild(compilationUnit.Children[i]);
compilationUnit.Children[i] = ns;
}
}
}
ToCSharpConvertVisitor v = new ToCSharpConvertVisitor();
compilationUnit.AcceptVisitor(v, data);
if (projectContent != null && projectContent.DefaultImports != null) {
int index = 0;
foreach (string u in projectContent.DefaultImports.Usings) {
compilationUnit.Children.Insert(index++, new UsingDeclaration(u));
}
}
return null;
}
public override object VisitNamespaceDeclaration(ICSharpCode.NRefactory.Ast.NamespaceDeclaration namespaceDeclaration, object data)
{
namespaceStack.Push(namespaceDeclaration.Name);
object result = base.VisitNamespaceDeclaration(namespaceDeclaration, data);
namespaceStack.Pop();
return(result);
}
public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
CSharpLanguage.VisitorData visitorData = (CSharpLanguage.VisitorData) data;
visitorData.CurrentNamespaces.Push(namespaceDeclaration.get_Name());
((AbstractNode) namespaceDeclaration).AcceptChildren((IAstVisitor) this, (object) visitorData);
visitorData.CurrentNamespaces.Pop();
return (object) null;
}
public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
CSharpLanguage.VisitorData data2 = (CSharpLanguage.VisitorData) data;
data2.CurrentNamespaces.Push(namespaceDeclaration.Name);
namespaceDeclaration.AcceptChildren(this, data2);
data2.CurrentNamespaces.Pop();
return null;
}
public static NamespaceDeclaration add_Namespace(this CompilationUnit compilationUnit, string @namespace)
{
var newNamespace = compilationUnit.namespaces(@namespace); // check if already exists and if it does return it
if (newNamespace != null)
return newNamespace;
newNamespace = new NamespaceDeclaration(@namespace);
compilationUnit.Children.Add(newNamespace);
return newNamespace;
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
NamespaceDeclaration replacedNamespace = namespaceDeclaration;
UsingDeclaration usingDeclaration = new UsingDeclaration("java.lang.*");
replacedNamespace.Children.Insert(0, usingDeclaration);
ReplaceCurrentNode(replacedNamespace);
return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
}
public override object VisitNamespaceDeclaration(ICSharpCode.NRefactory.Ast.NamespaceDeclaration namespaceDeclaration, object data)
{
var visitorData = (VisitorData)data;
visitorData.currentNamespaces.Push(namespaceDeclaration.Name);
namespaceDeclaration.AcceptChildren(this, visitorData);
visitorData.currentNamespaces.Pop();
return(null);
}
public void Setup()
{
mocks = new MockRepository();
typeResolver = mocks.DynamicMock<ITypeResolver>();
visitor = new TypeInspectionVisitor(typeResolver);
type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>()) {Name = "SomeType"};
@namespace = new NamespaceDeclaration("SomeNamespace");
@namespace.AddChild(type);
type.Parent = @namespace;
}
public void VisitingNamespace_MustAddParentNamespacesToTypeResolver()
{
var typeTables = new List<TypeTableEntry>();
var usings = new List<String>();
var aliases = new Dictionary<string, string>();
var resolver = new TypeResolver(typeTables, usings, aliases);
var nsDecl = new NamespaceDeclaration("System.Collections.Specialized");
var visitor = new TypeResolvingVisitor(resolver);
visitor.VisitNamespaceDeclaration(nsDecl, null);
Assert.AreEqual(3, usings.Count);
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
Removeables.Clear();
UsedTypes.Clear();
NamespaceDeclaration replaced = namespaceDeclaration;
IList types = AstUtil.GetChildrenWithType(replaced, typeof(TypeDeclaration));
foreach (TypeDeclaration typeDeclaration in types)
{
VisitTypeDeclaration(typeDeclaration, data);
}
ReplaceCurrentNode(replaced);
return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
}
public override object VisitNamespaceDeclaration(AST.NamespaceDeclaration namespaceDeclaration, object data)
{
DefaultUsingScope oldNamespace = currentNamespace;
foreach (string name in namespaceDeclaration.Name.Split('.'))
{
currentNamespace = new DefaultUsingScope();
currentNamespace.Parent = currentNamespace;
currentNamespace.NamespaceName = PrependCurrentNamespace(name);
currentNamespace.Parent.ChildScopes.Add(currentNamespace);
}
object ret = namespaceDeclaration.AcceptChildren(this, data);
currentNamespace = oldNamespace;
return(ret);
}
private void CreateTypeDeclarations(string jarFile)
{
LoadClasses(Path.GetFullPath(jarFile));
foreach (string package in classes.Keys)
{
if (!IsIncluded(package))
continue;
Console.WriteLine(package);
IDictionary types = new Hashtable();
IList packageClasses = (IList) classes[package];
foreach (ClassFile cf in packageClasses)
{
if (cf.IsPublic)
{
TypeDeclaration type = GetTypeDeclaration(cf);
types.Add(type.Name, type);
}
}
foreach (TypeDeclaration type in types.Values)
{
if (type.Name.IndexOf("$") == -1)
{
NamespaceDeclaration nameSpace = new NamespaceDeclaration(package);
type.Parent = nameSpace;
nameSpace.AddChild(type);
CompilationUnit cu = new CompilationUnit();
cu.Children.Add(nameSpace);
compilationUnits.Add(cu);
}
else
{
string parentName = type.Name.Substring(0, type.Name.IndexOf("$"));
TypeDeclaration parent = (TypeDeclaration) types[GetTypeName(parentName)];
if (parent != null)
{
type.Name = GetTypeName(type.Name);
parent.AddChild(type);
}
}
}
}
}
public override object VisitNamespaceDeclaration (NamespaceDeclaration node, object data)
{
if (!String.IsNullOrEmpty (Namespace))
throw CreateException (node, "Nested namespaces are not supported");
string prevNamespace = Namespace;
//var prevUsings = Usings;
Namespace = node.Name;
//Usings = new HashSet<string> ();
node.AcceptChildren (this, null);
Namespace = prevNamespace;
//Usings = prevUsings;
return null;
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
similarTypes = new Hashtable();
IList usings = AstUtil.GetChildrenWithType(namespaceDeclaration, typeof(UsingDeclaration));
foreach (UsingDeclaration usingDeclaration in usings)
{
Using usi = (Using) usingDeclaration.Usings[0];
string fullName = GetFullyQualifiedName(usi);
string type = GetShortReferenceTypeName(usi);
string projectType = namespaceDeclaration.Name + "." + type;
if (CodeBase.Types.Contains(projectType))
similarTypes.Add(type, fullName);
}
if (similarTypes.Count < 1)
return null;
else
return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
}
public override object VisitNamespaceDeclaration(AST.NamespaceDeclaration namespaceDeclaration, object data)
{
string name;
if (currentNamespace.Count == 0)
{
name = namespaceDeclaration.Name;
}
else
{
name = currentNamespace.Peek() + '.' + namespaceDeclaration.Name;
}
currentNamespace.Push(name);
object ret = namespaceDeclaration.AcceptChildren(this, data);
currentNamespace.Pop();
return(ret);
}
public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
if (RootNamespaceToRemove != null) {
if (namespaceDeclaration.Name == RootNamespaceToRemove) {
// remove namespace declaration
INode insertAfter = namespaceDeclaration;
foreach (INode child in namespaceDeclaration.Children) {
InsertAfterSibling(insertAfter, child);
insertAfter = child;
}
namespaceDeclaration.Children.Clear();
RemoveCurrentNode();
} else if (namespaceDeclaration.Name.StartsWith(RootNamespaceToRemove + ".")) {
namespaceDeclaration.Name = namespaceDeclaration.Name.Substring(RootNamespaceToRemove.Length + 1);
}
}
base.VisitNamespaceDeclaration(namespaceDeclaration, data);
return null;
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
IList addingUsings = new ArrayList();
base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, addingUsings);
if (addingUsings.Count > 0)
{
NamespaceDeclaration replaceNamespace = namespaceDeclaration;
List<INode> children = namespaceDeclaration.Children;
INode[] childMembers = new INode[children.Count];
children.CopyTo(childMembers);
replaceNamespace.Children.Clear();
foreach (UsingDeclaration usi in addingUsings)
replaceNamespace.Children.Add(usi);
foreach (INode node in childMembers)
{
replaceNamespace.Children.Add(node);
}
ReplaceCurrentNode(replaceNamespace);
}
return null;
}
public void AddUsing(NamespaceDeclaration namespaceDeclaration, IList usings, UsingDeclaration usingDeclaration)
{
Using usin = (Using) usingDeclaration.Usings[0];
string alias = null;
string name = usin.Name;
if (!usin.IsAlias)
name = name.Substring(name.LastIndexOf('.') + 1);
else
alias = usin.Alias.Type;
if (CodeBase.References.Contains(name))
{
string reference = (string) CodeBase.References[name];
alias = alias.Replace("." + name, "." + reference);
TypeReference typeReference = AstUtil.GetTypeReference(alias, namespaceDeclaration);
UsingDeclaration addingUsingDeclaration = new UsingDeclaration(reference, typeReference);
if (!Contains(usings, addingUsingDeclaration))
{
namespaceDeclaration.Children.Insert(0, addingUsingDeclaration);
}
}
}
void NamespaceMemberDecl() {
//#line 361 "VBNET.ATG"
ModifierList m = new ModifierList();
AttributeSection section;
List<AttributeSection> attributes = new List<AttributeSection>();
string qualident;
if (la.kind == 160) {
lexer.NextToken();
//#line 368 "VBNET.ATG"
Location startPos = t.Location;
Qualident(
//#line 370 "VBNET.ATG"
out qualident);
//#line 372 "VBNET.ATG"
INode node = new NamespaceDeclaration(qualident);
node.StartLocation = startPos;
AddChild(node);
BlockStart(node);
EndOfStmt();
NamespaceBody();
//#line 380 "VBNET.ATG"
node.EndLocation = t.Location;
BlockEnd();
} else if (StartOf(2)) {
while (la.kind == 40) {
AttributeSection(
//#line 384 "VBNET.ATG"
out section);
//#line 384 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(3)) {
TypeModifier(
//#line 385 "VBNET.ATG"
m);
}
NonModuleDeclaration(
//#line 385 "VBNET.ATG"
m, attributes);
} else SynErr(245);
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
return namespaceDeclaration.AcceptChildren(this, data);
}
public sealed override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
this.BeginVisit(namespaceDeclaration);
object result = this.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
this.EndVisit(namespaceDeclaration);
return result;
}
public virtual object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
}
public override List<Change> PerformChanges (RefactoringOptions options, object prop)
{
IResolver resolver = options.GetResolver ();
List<Change> result = new List<Change> ();
INRefactoryASTProvider provider = options.GetASTProvider ();
if (resolver == null || provider == null)
return result;
TypeDeclaration newType = new TypeDeclaration (ICSharpCode.NRefactory.Ast.Modifiers.None, null);
newType.Name = createExpression.CreateType.Type;
newType.Type = GetNewTypeType ();
ConstructorDeclaration constructor = new ConstructorDeclaration (newType.Name, ICSharpCode.NRefactory.Ast.Modifiers.Public, null, null);
constructor.Body = new BlockStatement ();
int i = 0;
foreach (Expression expression in createExpression.Parameters) {
i++;
string output = provider.OutputNode (options.Dom, expression);
string parameterName;
if (Char.IsLetter (output[0]) || output[0] == '_') {
parameterName = output;
} else {
parameterName = "par" + i;
}
ResolveResult resolveResult2 = resolver.Resolve (new ExpressionResult (output), options.ResolveResult.ResolvedExpression.Region.Start);
TypeReference typeReference = new TypeReference (resolveResult2.ResolvedType.ToInvariantString ());
typeReference.IsKeyword = true;
ParameterDeclarationExpression pde = new ParameterDeclarationExpression (typeReference, parameterName);
constructor.Parameters.Add (pde);
}
ICSharpCode.NRefactory.Ast.INode node = newType;
IType curType = options.Document.CompilationUnit.GetTypeAt (options.Document.TextEditor.CursorLine, options.Document.TextEditor.CursorColumn);
if (curType != null && !string.IsNullOrEmpty (curType.Namespace)) {
NamespaceDeclaration namespaceDeclaration = new NamespaceDeclaration (curType.Namespace);
namespaceDeclaration.Children.Add (newType);
node = namespaceDeclaration;
}
newType.Children.Add (constructor);
string fileName = GetName (Path.Combine (Path.GetDirectoryName (options.Document.FileName), newType.Name + Path.GetExtension (options.Document.FileName)));
string header = options.Dom.Project is DotNetProject ? StandardHeaderService.GetHeader (options.Dom.Project, fileName, true) + Environment.NewLine : "";
CreateFileChange createFile = new CreateFileChange (fileName, header + provider.OutputNode (options.Dom, node));
result.Add (createFile);
result.Add (new OpenFileChange (fileName));
return result;
}
public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
throw new global::System.NotImplementedException("NamespaceDeclaration");
}
void NamespaceMemberDecl() {
#line 341 "VBNET.ATG"
ModifierList m = new ModifierList();
AttributeSection section;
List<AttributeSection> attributes = new List<AttributeSection>();
string qualident;
if (la.kind == 146) {
lexer.NextToken();
#line 348 "VBNET.ATG"
Location startPos = t.Location;
Qualident(
#line 350 "VBNET.ATG"
out qualident);
#line 352 "VBNET.ATG"
INode node = new NamespaceDeclaration(qualident);
node.StartLocation = startPos;
compilationUnit.AddChild(node);
compilationUnit.BlockStart(node);
EndOfStmt();
NamespaceBody();
#line 360 "VBNET.ATG"
node.EndLocation = t.Location;
compilationUnit.BlockEnd();
} else if (StartOf(2)) {
while (la.kind == 28) {
AttributeSection(
#line 364 "VBNET.ATG"
out section);
#line 364 "VBNET.ATG"
attributes.Add(section);
}
while (StartOf(3)) {
TypeModifier(
#line 365 "VBNET.ATG"
m);
}
NonModuleDeclaration(
#line 365 "VBNET.ATG"
m, attributes);
} else SynErr(228);
}
public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
if (this.CheckNode(namespaceDeclaration)) {
return null;
}
return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
}
void NamespaceMemberDecl() {
#line 335 "cs.ATG"
AttributeSection section;
List<AttributeSection> attributes = new List<AttributeSection>();
ModifierList m = new ModifierList();
string qualident;
if (la.kind == 88) {
lexer.NextToken();
#line 341 "cs.ATG"
Location startPos = t.Location;
Qualident(
#line 342 "cs.ATG"
out qualident);
#line 342 "cs.ATG"
INode node = new NamespaceDeclaration(qualident);
node.StartLocation = startPos;
AddChild(node);
BlockStart(node);
Expect(16);
while (la.kind == 71) {
ExternAliasDirective();
}
while (la.kind == 121) {
UsingDirective();
}
while (StartOf(1)) {
NamespaceMemberDecl();
}
Expect(17);
if (la.kind == 11) {
lexer.NextToken();
}
#line 352 "cs.ATG"
node.EndLocation = t.EndLocation;
BlockEnd();
} else if (StartOf(2)) {
while (la.kind == 18) {
AttributeSection(
#line 356 "cs.ATG"
out section);
#line 356 "cs.ATG"
attributes.Add(section);
}
while (StartOf(3)) {
TypeModifier(
#line 357 "cs.ATG"
m);
}
TypeDecl(
#line 358 "cs.ATG"
m, attributes);
} else SynErr(148);
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
IList usings = AstUtil.GetChildrenWithType(namespaceDeclaration, typeof(UsingDeclaration));
foreach (UsingDeclaration usi in usings)
{
AddUsing(namespaceDeclaration, usings, usi);
}
return base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
}
internal static void EvaluateNamespaceLOC (MetricsContext ctx, NamespaceDeclaration node)
{
if(node == null)
return;
//MessageService.ShowMessage(node.ToString());
try {
NamespaceProperties namespaceRef = ComplexityMetrics.ProjProp.GetNamespaceReference(node.Name);
if(namespaceRef==null)
return;
Dictionary<int, ICSharpCode.NRefactory.Ast.INode> typeLocations = new Dictionary<int, ICSharpCode.NRefactory.Ast.INode>();
foreach(var childnode in node.Children){
if(childnode is TypeDeclaration)
typeLocations.Add(childnode.StartLocation.Line, childnode);
}
if(namespaceRef.FilePath==null||namespaceRef.FilePath=="")
namespaceRef.FilePath = ComplexityMetrics.File.FilePath;
#region CommonLogic
int startIndex = node.StartLocation.Line;
int endIndex = node.EndLocation.Line;
ulong totalLines = 0, totalRealLines = 0, totalCommentedLines = 0;
int realLines = 0;
bool isSingleLineComment = false;
bool isMultipleLineComment = false;
for(int i=startIndex;i<endIndex;i++)
{
string lineText = ComplexityMetrics.FileDoc.GetTextAt(ComplexityMetrics.FileText[i]).Trim();
if(isMultipleLineComment){
totalCommentedLines++;
if(lineText.EndsWith("*/"))
isMultipleLineComment = false;
continue;
}
if(lineText.StartsWith ("/*")){
isMultipleLineComment = true;
totalCommentedLines++;
continue;
}
isSingleLineComment = lineText.StartsWith ("//");
if(isSingleLineComment)
totalCommentedLines++;
if (lineText.Length > 0 && !isSingleLineComment)
{
realLines++;
if((typeLocations.ContainsKey(i)) && (typeLocations[i] is TypeDeclaration))
i = EvaluateTypeLOC(ctx, namespaceRef, (TypeDeclaration)typeLocations[i], i);
if((typeLocations.ContainsKey(i+1)) &&(typeLocations[i+1] is TypeDeclaration))
i = EvaluateTypeLOC(ctx, namespaceRef, (TypeDeclaration)typeLocations[i+1], i);
}
}
totalLines += (ulong)(startIndex-endIndex+1);
totalRealLines += (ulong)realLines;
namespaceRef.LOCReal += totalRealLines;
namespaceRef.LOCComments += totalCommentedLines;
#endregion CommonLogic
} catch (Exception e) {
Console.WriteLine(e.ToString());
}
}
public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
includeCommentsAfterLine = namespaceDeclaration.EndLocation.Y;
if (firstType) {
includeCommentsUpToLine = namespaceDeclaration.StartLocation.Y;
return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
} else {
RemoveCurrentNode();
return null;
}
}
public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
CodeNamespace currentNamespace = new CodeNamespace(namespaceDeclaration.Name);
//namespaces.Add(currentNamespace);
// add imports from mother namespace
foreach (CodeNamespaceImport import in ((CodeNamespace)namespaceDeclarations.Peek()).Imports) {
currentNamespace.Imports.Add(import);
}
namespaceDeclarations.Push(currentNamespace);
namespaceDeclaration.AcceptChildren(this, data);
namespaceDeclarations.Pop();
codeCompileUnit.Namespaces.Add(currentNamespace);
// Nested namespaces are not allowed in CodeDOM
return null;
}
