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;
}
