public object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { foreach (Using u in usingDeclaration.Usings) { VisitUsing(u, data); } return null; }
void UsingDirective() { #line 189 "cs.ATG" string qualident = null; TypeReference aliasedType = null; Expect(121); #line 192 "cs.ATG" Location startPos = t.Location; Qualident( #line 193 "cs.ATG" out qualident); if (la.kind == 3) { lexer.NextToken(); NonArrayType( #line 194 "cs.ATG" out aliasedType); } Expect(11); #line 196 "cs.ATG" if (qualident != null && qualident.Length > 0) { INode node; if (aliasedType != null) { node = new UsingDeclaration(qualident, aliasedType); } else { node = new UsingDeclaration(qualident); } node.StartLocation = startPos; node.EndLocation = t.EndLocation; compilationUnit.AddChild(node); } }
public void RemoveCurrentNamespaceUsings() { string program = @"package Janett.Translator; public class Translation { }"; string expected = @"namespace Janett.Translator { public class Translation { } }"; CompilationUnit cu = TestUtil.ParseProgram(program); NamespaceDeclaration ns = (NamespaceDeclaration) cu.Children[0]; UsingDeclaration us1 = new UsingDeclaration("Refactoring", AstUtil.GetTypeReference("Janett.Translator.Refactoring", ns)); UsingDeclaration us2 = new UsingDeclaration("Transformation", AstUtil.GetTypeReference("Janett.Translator.Transformation", ns)); ns.Children.Insert(0, us2); ns.Children.Insert(0, us1); us1.Parent = ns; us2.Parent = ns; VisitCompilationUnit(cu, null); TestUtil.CodeEqual(expected, TestUtil.GenerateCode(cu)); }
public override object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { Using usi = (Using) usingDeclaration.Usings[0]; string type = GetShortReferenceTypeName(usi); if (similarTypes.Contains(type)) RemoveCurrentNode(); return null; }
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { base.VisitUsingDeclaration(usingDeclaration, data); if (usingDeclaration.Usings.Count == 0) { RemoveCurrentNode(); } return null; }
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { base.VisitUsingDeclaration(usingDeclaration, data); if (usingDeclaration.Parent is NamespaceDeclaration) { nodesToMoveToCompilationUnit.Add(usingDeclaration); RemoveCurrentNode(); } return null; }
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 VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { foreach (var usingLine in usingDeclaration.Usings) if (usingLine.IsAlias) TypeResolver.AliasNamespace(usingLine.Name, usingLine.Alias.Type); else TypeResolver.UseNamespace(usingLine.Name); return base.VisitUsingDeclaration(usingDeclaration, data); }
public override object VisitUsingDeclaration(AST.UsingDeclaration usingDeclaration, object data) { DefaultUsing us = new DefaultUsing(cu.ProjectContent, GetRegion(usingDeclaration.StartLocation, usingDeclaration.EndLocation)); foreach (AST.Using u in usingDeclaration.Usings) { u.AcceptVisitor(this, us); } currentNamespace.Usings.Add(us); return(data); }
public override object VisitUsingDeclaration (UsingDeclaration node, object data) { //Usings = new HashSet<string> (); foreach (Using item in node.Usings) { if (item.IsAlias) throw CreateException (node, "Aliases not are supported"); if (!Usings.Contains (item.Name)) Usings.Add (item.Name); } return null; }
private void AddUsing(INode currentNode, object data, string name) { string ns = name.Substring(name.LastIndexOf('.') + 1); NamespaceDeclaration namespaceDeclaration = (NamespaceDeclaration) AstUtil.GetParentOfType(currentNode, typeof(NamespaceDeclaration)); UsingDeclaration usingDeclaration = new UsingDeclaration(ns); usingDeclaration.Parent = namespaceDeclaration; ((Using) usingDeclaration.Usings[0]).Alias = AstUtil.GetTypeReference(name, usingDeclaration); IList usings = AstUtil.GetChildrenWithType(namespaceDeclaration, typeof(UsingDeclaration)); if (! ContainsUsing(usings, usingDeclaration) && !ContainsUsing((IList) data, usingDeclaration)) ((IList) data).Add(usingDeclaration); }
public static UsingDeclaration add_Using(this CompilationUnit compilationUnit, string @namespace) { @namespace = @namespace.remove(";").trim(); var currentUsingDeclaration = compilationUnit.@using(@namespace); if (currentUsingDeclaration != null) // these UsingDeclaration & Using classes are a bit of a mess (need to normalize this later) return new UsingDeclaration(currentUsingDeclaration.wrapOnList()); var newUsing = new UsingDeclaration(@namespace); compilationUnit.insert(newUsing); return newUsing; }
public void FieldTwoLayerInvocation() { string program = TestUtil.StatementParse("Field f; f.getName().indexOf('$')"); string expected = TestUtil.StatementParse("Field f; java.lang.String.instancehelper_indexOf(f.getName(), '$')"); CompilationUnit cu = TestUtil.ParseProgram(program); CompilationUnit cv = TestUtil.ParseProgram(expected); UsingDeclaration usiDec = new UsingDeclaration("Field", new TypeReference("java.lang.reflect.Field")); ((NamespaceDeclaration) cu.Children[0]).Children.Insert(0, usiDec); ((NamespaceDeclaration) cv.Children[0]).Children.Insert(0, usiDec); VisitCompilationUnit(cu, null); TestUtil.CodeEqual(TestUtil.GenerateCode(cv), TestUtil.GenerateCode(cu)); }
public void AddAssembly(AssemblyDefinition assemblyDefinition) { Ast.UsingDeclaration astUsing = new Ast.UsingDeclaration("System"); astCompileUnit.Children.Add(astUsing); foreach(TypeDefinition typeDef in assemblyDefinition.MainModule.Types) { // Skip nested types - they will be added by the parent type if (typeDef.DeclaringType != null) continue; // Skip the <Module> class if (typeDef.Name == "<Module>") continue; AddType(typeDef); } }
public void Used() { string program = TestUtil.PackageMemberParse("public class A {object obj = new ToStringBuilder();}"); string expected = TestUtil.NamespaceMemberParse("using ToStringBuilder = NClassifier.Util.ToStringBuilder; public class A {object obj = new ToStringBuilder();}"); CompilationUnit cu = TestUtil.ParseProgram(program); NamespaceDeclaration ns = (NamespaceDeclaration) cu.Children[0]; UsingDeclaration us = new UsingDeclaration("ToStringBuilder", AstUtil.GetTypeReference("NClassifier.Util.ToStringBuilder", ns)); ns.Children.Insert(0, us); us.Parent = ns; Mode = "DotNet"; VisitCompilationUnit(cu, null); TestUtil.CodeEqual(expected, TestUtil.GenerateCode(cu)); }
private bool ContainsUsing(IList usingList, UsingDeclaration usingDec) { foreach (UsingDeclaration usi in usingList) { Using usingDeclared = (Using) usingDec.Usings[0]; Using usiUsing = (Using) usi.Usings[0]; if (usiUsing.IsAlias && usingDeclared.IsAlias) { if (usiUsing.Name == usingDeclared.Name && usiUsing.Alias.Type == usingDeclared.Alias.Type) return true; } else if (!(usiUsing.IsAlias && usingDeclared.IsAlias)) { if (usingDeclared.Name == usiUsing.Name) return true; } } return false; }
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); } } }
public override object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { Using usi = (Using) usingDeclaration.Usings[0]; if (usi.IsAlias) { string type = usi.Alias.Type; string usingNamespace = type.Substring(0, type.LastIndexOf('.')); if (usingDeclaration.Parent is NamespaceDeclaration) { NamespaceDeclaration namespaceDeclaration = (NamespaceDeclaration) usingDeclaration.Parent; if (namespaceDeclaration.Name == usingNamespace) { RemoveCurrentNode(); } else if (usingNamespace.StartsWith(namespaceDeclaration.Name)) { string movedType = namespaceDeclaration.Name + usingNamespace.Substring(usingNamespace.LastIndexOf('.')); if (CodeBase.Types.Contains(movedType)) RemoveCurrentNode(); } } } Intersect(Removeables, UsedTypes); if (Removeables.Count > 0) { if ((!usi.IsAlias && Removeables.Contains(usi.Name)) || (usi.IsAlias && Removeables.Contains(usi.Alias.Type))) RemoveCurrentNode(); } if (UsedTypes.Count > 0) { if ((!usi.IsAlias && !UsedTypes.Contains(usi.Name)) || (usi.IsAlias && !UsedTypes.Contains(usi.Alias.Type))) RemoveCurrentNode(); } return base.TrackedVisitUsingDeclaration(usingDeclaration, data); }
public virtual object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { return base.VisitUsingDeclaration(usingDeclaration, data); }
public sealed override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { this.BeginVisit(usingDeclaration); object result = this.TrackedVisitUsingDeclaration(usingDeclaration, data); this.EndVisit(usingDeclaration); return result; }
void ImportsStmt() { #line 299 "VBNET.ATG" List<Using> usings = new List<Using>(); Expect(124); #line 303 "VBNET.ATG" Location startPos = t.Location; Using u; ImportClause( #line 306 "VBNET.ATG" out u); #line 306 "VBNET.ATG" if (u != null) { usings.Add(u); } while (la.kind == 12) { lexer.NextToken(); ImportClause( #line 308 "VBNET.ATG" out u); #line 308 "VBNET.ATG" if (u != null) { usings.Add(u); } } EndOfStmt(); #line 312 "VBNET.ATG" UsingDeclaration usingDeclaration = new UsingDeclaration(usings); usingDeclaration.StartLocation = startPos; usingDeclaration.EndLocation = t.Location; compilationUnit.AddChild(usingDeclaration); }
public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { throw new global::System.NotImplementedException("UsingDeclaration"); }
private bool Contains(IList list, UsingDeclaration us) { foreach (UsingDeclaration usingDeclaration in list) { Using usi = (Using) usingDeclaration.Usings[0]; Using uss = (Using) us.Usings[0]; if (usi.Name == uss.Name) return true; } return false; }
void UsingDirective() { #line 196 "cs.ATG" string qualident = null; TypeReference aliasedType = null; string alias = null; Expect(121); #line 200 "cs.ATG" Location startPos = t.Location; if ( #line 201 "cs.ATG" IdentAndDoubleColon()) { Identifier(); #line 201 "cs.ATG" alias = t.val; Expect(10); } Qualident( #line 202 "cs.ATG" out qualident); if (la.kind == 3) { lexer.NextToken(); NonArrayType( #line 203 "cs.ATG" out aliasedType); } Expect(11); #line 205 "cs.ATG" if (qualident != null && qualident.Length > 0) { string name = (alias != null && alias != "global") ? alias + "." + qualident : qualident; INode node; if (aliasedType != null) { node = new UsingDeclaration(name, aliasedType); } else { node = new UsingDeclaration(name); } node.StartLocation = startPos; node.EndLocation = t.EndLocation; AddChild(node); } }
public override object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { foreach (Using @using in usingDeclaration.Usings) { this.AppendIndentedLine(string.Concat("from ", @using.Name, " import *")); } return null; }
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { foreach(var declaration in usingDeclaration.Usings) UsingDeclarations.Add(new AstValue<UsingDeclaration>(declaration.Name, usingDeclaration, usingDeclaration.StartLocation, usingDeclaration.EndLocation)); return null; }
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { foreach (Using u in usingDeclaration.Usings) { namespaceDeclarations.Peek().Imports.Add(new CodeNamespaceImport(u.Name)); } return null; }
/*public static UsingDeclaration add_Using(this CompilationUnit compilationUnit, string @namespace) { var newUsing = new UsingDeclaration(@namespace); //compilationUnit.Children.add(newUsing); //compilationUnit.Children.Insert(0, newUsing); compilationUnit.insert(newUsing); return newUsing; }*/ public static CompilationUnit add_Using(this CompilationUnit compilationUnit, UsingDeclaration usingDeclaration) { compilationUnit.insert(usingDeclaration); return compilationUnit; }
public override List<Change> PerformChanges (RefactoringOptions options, object properties) { List<Change> result = new List<Change> (); ICompilationUnit compilationUnit = options.ParseDocument ().CompilationUnit; Mono.TextEditor.TextEditorData textEditorData = options.GetTextEditorData (); int minOffset = int.MaxValue; foreach (IUsing u in compilationUnit.Usings) { if (u.IsFromNamespace) continue; int offset = textEditorData.Document.LocationToOffset (u.Region.Start.Line, u.Region.Start.Column); TextReplaceChange change = new TextReplaceChange () { FileName = options.Document.FileName, Offset = offset, RemovedChars = textEditorData.Document.LocationToOffset (u.Region.End.Line, u.Region.End.Column) - offset }; Mono.TextEditor.LineSegment line = textEditorData.Document.GetLineByOffset (change.Offset); if (line != null && line.EditableLength == change.RemovedChars) change.RemovedChars += line.DelimiterLength; result.Add (change); minOffset = Math.Min (minOffset, offset); } StringBuilder output = new StringBuilder (); List<IUsing> usings = new List<IUsing> (compilationUnit.Usings); usings.Sort (UsingComparer); INRefactoryASTProvider astProvider = options.GetASTProvider (); foreach (IUsing u in usings) { UsingDeclaration declaration; if (u.IsFromNamespace) continue; if (u.Aliases.Any ()) { KeyValuePair<string, IReturnType> alias = u.Aliases.First (); declaration = new UsingDeclaration (alias.Key, alias.Value.ConvertToTypeReference ()); } else { declaration = new UsingDeclaration (u.Namespaces.First ()); } output.Append (astProvider.OutputNode (options.Dom, declaration)); } TextReplaceChange insertSortedUsings = new TextReplaceChange () { FileName = options.Document.FileName, Offset = minOffset, InsertedText = output.ToString () }; result.Add (insertSortedUsings); return result; }
void ImportsStmt() { //#line 315 "VBNET.ATG" List<Using> usings = new List<Using>(); Expect(137); //#line 319 "VBNET.ATG" Location startPos = t.Location; Using u; ImportClause( //#line 322 "VBNET.ATG" out u); //#line 322 "VBNET.ATG" if (u != null) { usings.Add(u); } while (la.kind == 22) { lexer.NextToken(); ImportClause( //#line 324 "VBNET.ATG" out u); //#line 324 "VBNET.ATG" if (u != null) { usings.Add(u); } } EndOfStmt(); //#line 328 "VBNET.ATG" UsingDeclaration usingDeclaration = new UsingDeclaration(usings); usingDeclaration.StartLocation = startPos; usingDeclaration.EndLocation = t.Location; AddChild(usingDeclaration); }
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { if (firstType) { includeCommentsUpToLine = usingDeclaration.EndLocation.Y; } return null; }