public void MustThrowOnInvalidQualifiedIdentifier()
{
Assert.Throws <ArgumentException>(() => QualifiedIdentifier.Parse("Abcd:1234"));
Assert.Throws <ArgumentException>(() => QualifiedIdentifier.Parse("Вап.Fghj"));
Assert.Throws <ArgumentException>(() => QualifiedIdentifier.Parse("Abs..dfg"));
Assert.Throws <ArgumentException>(() => QualifiedIdentifier.Parse("Abs.dfg."));
}
private int ComputeHashCode()
{
return(HashCode.Compute(
((int)NodeType).GetHashCode(),
QualifiedIdentifier.GetHashCode(),
Expression.GetHashCode()));
}
public override void VisitNamespace(NamespaceSymbol @namespace)
{
Func<NamespaceSymbol, bool> hasInterestingMembers =
n => n.Members.Any(x => !(x is NamespaceSymbol) && !NotInterestedIn(x));
if (hasInterestingMembers(@namespace))
{
var nameParts = @namespace
.Recurse(x => x.Parent.ToMaybe<NamespaceSymbol>())
.TakeWhile(x => x == @namespace || !hasInterestingMembers(x))
.Select(x => x.Name)
.Reverse()
.ToArray();
var name = new QualifiedIdentifier(nameParts);
WriteLine("namespace {0}", name);
using (WithBlock())
base.VisitNamespace(@namespace);
WriteLine();
}
else
base.VisitNamespace(@namespace);
}
int ComputeHashCode()
{
return(HashCode.Compute(
QualifiedIdentifier.GetHashCode(),
Expression.GetHashCode(),
NodeType.GetHashCode()));
}
int ComputeHashCode()
{
return(HashCode.Compute(
((int)NodeType).GetHashCode(),
SettingIdentifier.GetHashCode(),
QualifiedIdentifier.GetHashCode()));
}
public void MustGetQualifiedIdentifierNamePart()
{
var qid = QualifiedIdentifier.Parse("Hellow.The.Best.World");
var name = Identifier.Parse("World");
Assert.Equal(name, qid.Name);
}
int ComputeHashCode()
{
return(HashCode.Compute(
NodeType.GetHashCode(),
Identifier.GetHashCode(),
QualifiedIdentifier.GetHashCode()));
}
private static IEnumerable<NamespaceSyntaxGroup> GroupNamespaces(QualifiedIdentifier parentName, Dictionary<QualifiedIdentifier, NamespaceSyntax[]> input, int skip)
{
var identifiers = input
.Where(x => ReferenceEquals(parentName, null) || x.Key.StartsWith(parentName))
.Select(x => x.Key
.OfType<Identifier>()
.Skip(skip)
.FirstOrDefault())
.NotNull()
.Distinct();
foreach (var identifier in identifiers)
{
var qualifiedIdentifier = !ReferenceEquals(parentName, null)
? new QualifiedIdentifier(parentName.Concat(new[] { identifier }))
: new QualifiedIdentifier(identifier);
var namespaces = input
.TryGetValue(qualifiedIdentifier)
.ValueOrDefault(new NamespaceSyntax[] { });
yield return new NamespaceSyntaxGroup(qualifiedIdentifier,
namespaces,
GroupNamespaces(qualifiedIdentifier, input, skip + 1));
}
}
public void MustGetQualifiedIdentifierNamespace()
{
var qid = QualifiedIdentifier.Parse("Hellow.The.Best.World");
var ns = QualifiedIdentifier.Parse("Hellow.The.Best");
Assert.Equal(ns, qid.Namespace);
}
public Maybe<ISymbol> Resolve(QualifiedIdentifier identifier, SymbolTable table)
{
return table.Resolve(identifier)
.Or(() => Usings
.Select(x => table.Resolve(x + identifier))
.Squash()
.FirstOrDefault());
}
protected string ValueToString(QualifiedIdentifier qualifiedIdentifier)
{
var parts = qualifiedIdentifier.NamespacePath
.Concat(qualifiedIdentifier.ItemName)
.Where(str => !string.IsNullOrEmpty(str))
.Select(e => $"\"{e}\"");
return($"new QualifiedIdentifier({string.Join(", ", parts)})");
}
public override Expression VisitQualifiedIdentifierCore(QualifiedIdentifier qualId)
{
Identifier id = qualId.Identifier;
Expression target = base.VisitQualifiedIdentifierCore(qualId);
if (target == null && !this.inCompatibilityMode && this.insideAssertion)
{
target = Looker.BindPseudoMember(qualId.Qualifier, qualId.Identifier);
}
return(target);
}
public Maybe<ISymbol> Resolve(QualifiedIdentifier identifier)
{
Guard.NotNull(identifier, "identifier");
return _BuiltInTypesMap.TryGetValue(identifier).OfType<ISymbol>()
.Or(() => _SymbolMap.TryGetValue(identifier))
.Or(() => _References.Select(x => x.GetType(identifier.ToString(), false))
.NotNull()
.Select(x => _BuiltInTypes.Contains(x) ? new BuiltInType(x) : new ExternalType(x))
.FirstOrDefault());
}
public void MustCompareIdentifierCaseInsensivity()
{
var id1 = Identifier.Parse("Hellow");
var id2 = Identifier.Parse("helloW");
Assert.Equal(id1, id2);
var qid1 = QualifiedIdentifier.Parse("Hellow.The.Best.World");
var qid2 = QualifiedIdentifier.Parse("helloW.the.BesT.WorlD");
Assert.Equal(qid1, qid2);
}
public void StartsWith_WorksCorrectly()
{
var identifier = new QualifiedIdentifier("ThomsonReuters.Languages.UnitTests");
Assert.IsTrue(identifier.StartsWith(new Identifier("ThomsonReuters")));
Assert.IsTrue(identifier.StartsWith(new QualifiedIdentifier("ThomsonReuters")));
Assert.IsTrue(identifier.StartsWith(new QualifiedIdentifier("ThomsonReuters.Languages")));
Assert.IsTrue(identifier.StartsWith(new QualifiedIdentifier("ThomsonReuters.Languages.UnitTests")));
Assert.IsFalse(identifier.StartsWith(new QualifiedIdentifier("ThomsonReuters.Languages.Tests")));
Assert.IsFalse(identifier.StartsWith(new QualifiedIdentifier("ThomsonReuters.Langs")));
Assert.IsFalse(identifier.StartsWith(new QualifiedIdentifier("ThomsonReuters.Foo")));
Assert.IsFalse(identifier.StartsWith(new QualifiedIdentifier("TR")));
}
public static Expression QualifiedIdentifierFor(params string[] memberNameParts)
{
if (memberNameParts == null || memberNameParts.Length < 1)
{
return(null);
}
Identifier id = Identifier.For(memberNameParts[0]);
id.Prefix = Identifier.For("global");
Expression qualId = id;
for (int i = 1, n = memberNameParts.Length; i < n; i++)
{
qualId = new QualifiedIdentifier(qualId, Identifier.For(memberNameParts[i]));
}
return(qualId);
}
public Maybe<ISymbol> Resolve(QualifiedIdentifier identifier, SymbolTable table)
{
var parentFullName = Parent.OfType<ISymbol>().Select(x => x.FullName);
return table.Resolve(FullName + identifier)
.Or(() => Usings
.Select(x => table.Resolve(x + identifier))
.Squash()
.TryFirst())
.Or(() => Name.Parent
.Recurse(x => x.Parent)
.Select(x => parentFullName
.Select(y => y + x + identifier)
.Or(() => x + identifier)
.SelectMaybe(table.Resolve))
.Squash()
.TryFirst())
.Or(() => Parent.OfType<IResolutionRoot>().SelectMaybe(x => x.Resolve(identifier, table)));
}
public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier){
if (qualifiedIdentifier == null) return null;
Expression result = this.VisitQualifiedIdentifierCore(qualifiedIdentifier);
if (result == null){
qualifiedIdentifier.Type = SystemTypes.Object;
return qualifiedIdentifier;
}
MemberBinding mb = result as MemberBinding;
if (mb == null) return result;
switch(mb.BoundMember.NodeType){
case NodeType.Property:
Property p = (Property)mb.BoundMember;
Method getter = p.Getter;
if (getter == null) getter = p.GetBaseGetter();
if (getter == null)
return mb;
if (getter.ObsoleteAttribute == null) getter.ObsoleteAttribute = p.ObsoleteAttribute;
mb.BoundMember = getter;
MethodCall mc = new MethodCall(mb, new ExpressionList());
if (!(mb.TargetObject is Base) && getter.IsVirtualAndNotDeclaredInStruct)
mc.NodeType = NodeType.Callvirt;
mc.SourceContext = qualifiedIdentifier.SourceContext;
mc.Type = p.Type;
return mc;
case NodeType.Field:
Field f = (Field)mb.BoundMember;
if (f.IsLiteral){
Literal defaultValue = f.DefaultValue;
if (defaultValue == null) defaultValue = f.DefaultValue = this.EvaluateAsLiteral(f.Initializer);
if (defaultValue != null) {
Literal lit = (Literal)defaultValue.Clone();
lit.SourceContext = mb.SourceContext;
lit = this.CoerceLiteral(mb, f, lit);
if (lit != null) return lit;
}
if (f.DeclaringType is EnumNode)
mb.TargetObject = null;
}
break;
//TODO: what about types?
}
return mb;
}
public NamespaceSyntaxGroup(QualifiedIdentifier fullName, IEnumerable<NamespaceSyntax> namespaces, IEnumerable<NamespaceSyntaxGroup> groups)
{
FullName = Guard.NotNull(fullName, "fullName");
Namespaces = Guard.NotNull(namespaces, "namespaces").ToArray();
Groups = Guard.NotNull(groups, "groups").ToArray();
}
public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier)
{
throw new ApplicationException("unimplemented");
}
public void MustParseValidQualifiedIdentifier()
{
QualifiedIdentifier.Parse("Abcd.Efgh");
QualifiedIdentifier.Parse("Abcd.Ef_12gh");
QualifiedIdentifier.Parse("Abcd.Efgh.F456");
}
public static void report(Node node, int shift)
{
if (node == null)
{
indent(shift);
Console.WriteLine("NULL ENTITY");
return;
}
switch (node.NodeType)
{
case NodeType.AliasDefinition:
{
AliasDefinition alias = node as AliasDefinition;
indent(shift);
Console.WriteLine("using {0} = {1};", alias.Alias.Name, alias.AliasedUri.Name);
break;
}
case NodeType.CompilationUnit:
case NodeType.CompilationUnitSnippet:
{
CompilationUnit cu = node as CompilationUnit;
for (int i = 0, n = cu.Nodes.Length; i < n; i++)
{
report(cu.Nodes[i], 0);
}
break;
}
case NodeType.Namespace:
{
Namespace ns = node as Namespace;
if (ns.UsedNamespaces != null && ns.UsedNamespaces.Length != 0)
{
indent(shift);
Console.WriteLine("using ");
for (int i = 0, n = ns.UsedNamespaces.Length; i < n; i++)
{
Console.Write("{0}", ns.UsedNamespaces[i].Namespace.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine();
}
indent(shift);
Console.WriteLine("namespace {0}", ns.FullNameId.Name);
indent(shift);
Console.WriteLine("{");
if (ns.AliasDefinitions != null && ns.AliasDefinitions.Length != 0)
{
for (int i = 0, n = ns.AliasDefinitions.Length; i < n; i++)
{
report(ns.AliasDefinitions[i], shift + ind);
}
}
if (ns.NestedNamespaces != null && ns.NestedNamespaces.Length != 0)
{
for (int i = 0, n = ns.NestedNamespaces.Length; i < n; i++)
{
report(ns.NestedNamespaces[i], shift + ind);
}
}
if (ns.Types != null && ns.Types.Length != 0)
{
for (int i = 0, n = ns.Types.Length; i < n; i++)
{
report(ns.Types[i], shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Class:
{
Class cls = node as Class;
if (cls == SystemTypes.Object)
{
Console.Write(cls.Name);
break;
}
indent(shift);
if (cls.IsAbstract)
{
Console.Write("abstract ");
}
if (cls.IsPrivate)
{
Console.Write("private ");
}
else if (cls.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ??????????????
}
if (cls.IsSealed)
{
Console.Write("sealed ");
}
Console.Write("class ");
if (cls.DeclaringType != null)
{
Console.Write("{0}::", cls.DeclaringType.Name.Name);
}
Console.Write("{0}", cls.Name != null?cls.Name.Name:"<NONAME>");
if (cls.BaseClass != null)
{
Console.Write(" : {0}", cls.BaseClass.Name.Name);
}
if (cls.Interfaces != null && cls.Interfaces.Length != 0)
{
if (cls.BaseClass != null)
{
Console.Write(",");
}
else
{
Console.Write(" :");
}
for (int i = 0, n = cls.Interfaces.Length; i < n; i++)
{
Interface interfac = cls.Interfaces[i];
if (interfac != null)
{
Console.Write(" {0}", interfac.Name.Name);
}
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.WriteLine();
indent(shift);
Console.WriteLine("{");
if (cls.Members != null && cls.Members.Length != 0)
{
for (int i = 0, n = cls.Members.Length; i < n; i++)
{
Member member = cls.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Struct:
{
Struct struc = node as Struct;
indent(shift);
if (struc.IsAbstract)
{
Console.Write("abstract ");
}
if (struc.IsPrivate)
{
Console.Write("private ");
}
else if (struc.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ??????????????
}
if (struc.IsSealed)
{
Console.Write("sealed ");
}
Console.Write("struct ");
if (struc.DeclaringType != null)
{
Console.Write("{0}::", struc.DeclaringType.Name.Name);
}
Console.Write("{0}", struc.Name != null?struc.Name.Name:"<NONAME>");
if (struc.Interfaces != null && struc.Interfaces.Length != 0)
{
Console.Write(" :");
for (int i = 0, n = struc.Interfaces.Length; i < n; i++)
{
Interface interfac = struc.Interfaces[i];
if (interfac != null)
{
Console.Write(" {0}", interfac.Name.Name);
}
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.WriteLine();
indent(shift);
Console.WriteLine("{");
if (struc.Members != null && struc.Members.Length != 0)
{
for (int i = 0, n = struc.Members.Length; i < n; i++)
{
Member member = struc.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.EnumNode:
{
EnumNode enume = node as EnumNode;
indent(shift);
if (enume.Name != null && enume.Name.Name != null)
{
Console.Write("enum {0} = ", enume.Name.Name);
}
else
{
Console.Write("enum <NONAME> = ");
}
Console.Write("{");
for (int i = 0, n = enume.Members.Length; i < n; i++)
{
Field enumerator = (Field)enume.Members[i];
Console.Write("{0}", enumerator.Name.Name);
if (enumerator.DefaultValue != null)
{
Console.Write(" = {0}", enumerator.DefaultValue.ToString());
}
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine("};");
break;
}
case NodeType.Interface:
{
Interface interfac = node as Interface;
indent(shift);
if (interfac.IsAbstract)
{
Console.Write("abstract ");
}
if (interfac.IsPrivate)
{
Console.Write("private ");
}
else if (interfac.IsPublic)
{
Console.Write("public ");
}
else
{
Console.Write("internal "); // ???????????
}
Console.WriteLine("interface {0}", interfac.Name.Name);
indent(shift);
Console.WriteLine("{");
if (interfac.Members != null && interfac.Members.Length != 0)
{
for (int i = 0, n = interfac.Members.Length; i < n; i++)
{
Member member = interfac.Members[i];
if (member == null)
{
indent(shift + ind);
Console.WriteLine("<UNRESOLVED MEMBER>");
continue;
}
report(member, shift + ind);
}
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Method:
case NodeType.InstanceInitializer:
{
Method method = node as Method;
indent(shift);
if (method.IsAbstract)
{
Console.Write("abstract ");
}
if (method.IsPublic)
{
Console.Write("public ");
}
if (method.IsStatic)
{
Console.Write("static ");
}
if (method.IsVirtual)
{
Console.Write("virtual ");
}
if (method.IsPrivate)
{
Console.Write("private ");
}
if (method.OverriddenMethod != null)
{
Console.Write("override ");
}
if (method.ReturnType != null && method.ReturnType.Name != null)
{
Console.Write("{0} ", method.ReturnType.Name.Name);
}
if (method.Name != null)
{
if (method.ImplementedInterfaceMethods != null && method.ImplementedInterfaceMethods.Length != 0)
{
Method interf = method.ImplementedInterfaceMethods[0];
if (interf != null)
{
string name = interf.DeclaringType.Name.Name;
Console.Write("{0}.", name);
}
}
Console.Write("{0}", method.Name.Name);
}
Console.Write(" (");
if (method.Parameters != null && method.Parameters.Length != 0)
{
for (int i = 0, n = method.Parameters.Length; i < n; i++)
{
Parameter par = method.Parameters[i];
if (par == null)
{
continue;
}
if ((par.Flags & ParameterFlags.In) != 0)
{
Console.Write("in ");
}
if ((par.Flags & ParameterFlags.Out) != 0)
{
Console.Write("out ");
}
if (par.Type != null && par.Type.Name != null)
{
Console.Write("{0}", par.Type.Name.Name);
}
else
{
report(par.Type, 0);
}
Console.Write(" {0}", par.Name.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
}
Console.Write(" )");
// method body
if (method.Body != null)
{
Console.WriteLine();
report(method.Body, shift);
}
else
{
Console.WriteLine(";");
}
break;
}
case NodeType.DelegateNode:
{
DelegateNode dn = node as DelegateNode;
indent(shift);
Console.Write("delegate ");
if (dn.ReturnType != null && dn.ReturnType.Name != null)
{
Console.Write("{0} ", dn.ReturnType.Name.Name);
}
if (dn.Name != null)
{
Console.Write("{0}", dn.Name.Name);
}
Console.Write(" (");
if (dn.Parameters != null && dn.Parameters.Length != 0)
{
for (int i = 0, n = dn.Parameters.Length; i < n; i++)
{
Parameter par = dn.Parameters[i];
if (par == null)
{
continue;
}
if ((par.Flags & ParameterFlags.In) != 0)
{
Console.Write("in ");
}
if ((par.Flags & ParameterFlags.Out) != 0)
{
Console.Write("out ");
}
if (par.Type != null && par.Type.Name != null)
{
Console.Write("{0}", par.Type.Name.Name);
}
else
{
report(par.Type, 0);
}
Console.Write(" {0}", par.Name.Name);
if (i < n - 1)
{
Console.Write(", ");
}
}
}
Console.WriteLine(" );");
break;
}
case NodeType.StaticInitializer:
{
StaticInitializer si = node as StaticInitializer;
indent(shift);
Console.WriteLine("static {0} ( )", si.Name.Name);
// body
if (si.Body != null)
{
report(si.Body, shift);
}
else
{
Console.WriteLine("NO BODY");
}
break;
}
case NodeType.FieldInitializerBlock:
{
FieldInitializerBlock initializers = node as FieldInitializerBlock;
indent(shift);
if (initializers.IsStatic)
{
Console.Write("static ");
}
Console.WriteLine("init {");
for (int i = 0, n = initializers.Statements.Length; i < n; i++)
{
report(initializers.Statements[i], shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Base:
{
Console.Write("base");
break;
}
case NodeType.Field:
{
Field field = node as Field;
indent(shift);
if (field.IsPrivate)
{
Console.Write("private ");
}
else if (field.IsPublic)
{
Console.Write("public ");
}
if (field.IsStatic)
{
Console.Write("static ");
}
if (field.IsInitOnly)
{
Console.Write("readonly ");
}
if (field.Type != null)
{
if (field.Type.Name != null)
{
Console.Write("{0}", field.Type.Name.Name);
}
else
{
report(field.Type, 0);
}
}
Console.Write(" {0}", field.Name.Name);
if (field.Initializer != null)
{
Console.Write(" = ");
report(field.Initializer, 0);
}
Console.WriteLine(";");
break;
}
case NodeType.VariableDeclaration:
{
VariableDeclaration variable = node as VariableDeclaration;
indent(shift);
if (variable.Type != null && variable.Type.Name != null)
{
Console.Write("{0}", variable.Type.Name.Name);
}
else
{
report(variable.Type, 0);
}
Console.Write(" {0}", variable.Name.Name);
if (variable.Initializer != null)
{
Console.Write(" = ");
report(variable.Initializer, 0);
}
Console.WriteLine(";");
break;
}
case NodeType.LocalDeclarationsStatement:
{
LocalDeclarationsStatement stmt = node as LocalDeclarationsStatement;
indent(shift);
TypeNode type = stmt.Type;
if (type != null && type.Name != null)
{
Console.Write("{0}", type.Name.Name);
}
else
{
report(type, 0);
}
Console.Write(" ");
LocalDeclarationList list = stmt.Declarations;
for (int i = 0, n = list.Length; i < n; i++)
{
LocalDeclaration local = list[i];
Console.Write("{0}", local.Name.Name);
if (local.InitialValue != null)
{
Console.Write(" = ");
report(local.InitialValue, 0);
}
if (i < n - 1)
{
Console.Write(", ");
}
}
Console.WriteLine(";");
break;
}
case NodeType.Property:
{
Property property = node as Property;
indent(shift);
if (property.IsPrivate)
{
Console.Write("private ");
}
else if (property.IsPublic)
{
Console.Write("public ");
}
if (property.IsStatic)
{
Console.Write("static ");
}
if (property != null)
{
if (property.Type != null && property.Type.Name != null)
{
Console.Write("{0} ", property.Type.Name.Name);
}
if (property.ImplementedTypes != null)
{
TypeNode typ = property.ImplementedTypes[0];
Console.Write("{0}.", typ.Name.Name);
}
if (property.Name != null)
{
Console.WriteLine("{0}", property.Name.Name);
}
}
indent(shift);
Console.WriteLine("{");
if (property.Getter != null)
{
report(property.Getter, shift + ind);
}
if (property.Setter != null)
{
report(property.Setter, shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Lock:
{
Lock _lock = node as Lock;
indent(shift);
Console.Write("lock(");
report(_lock.Guard, shift);
Console.WriteLine(")");
report(_lock.Body, shift + ind);
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Block:
{
Block block = node as Block;
if (block == null || block.Statements == null)
{
break;
}
indent(shift);
Console.WriteLine("{");
for (int i = 0, n = block.Statements.Length; i < n; i++)
{
report(block.Statements[i], shift + ind);
Console.WriteLine();
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.MemberBinding:
{
MemberBinding mb = node as MemberBinding;
if (mb.TargetObject != null)
{
report(mb.TargetObject, 0);
}
else if (mb.BoundMember != null && mb.BoundMember.DeclaringType != null)
{
Console.Write(mb.BoundMember.DeclaringType.Name);
}
Console.Write(".");
if (mb.BoundMember.Name != null)
{
Console.Write(mb.BoundMember.Name.Name);
}
else
{
report(mb.BoundMember, 0);
}
break;
}
case NodeType.AssignmentStatement:
{
AssignmentStatement assignment = node as AssignmentStatement;
indent(shift);
report(assignment.Target, 0);
switch (assignment.Operator)
{
case NodeType.Nop: Console.Write(" = "); break;
case NodeType.Add: Console.Write(" += "); break;
case NodeType.Add_Ovf: Console.Write(" += "); break;
case NodeType.Add_Ovf_Un: Console.Write(" += "); break;
case NodeType.Sub: Console.Write(" -= "); break;
case NodeType.Sub_Ovf: Console.Write(" -= "); break;
case NodeType.Sub_Ovf_Un: Console.Write(" -= "); break;
case NodeType.Mul: Console.Write(" *= "); break;
case NodeType.Mul_Ovf: Console.Write(" *= "); break;
case NodeType.Mul_Ovf_Un: Console.Write(" *= "); break;
}
report(assignment.Source, 0);
Console.Write(";");
break;
}
case NodeType.ExpressionStatement:
{
ExpressionStatement exprStatement = node as ExpressionStatement;
indent(shift);
report(exprStatement.Expression, 0);
Console.Write(";");
break;
}
case NodeType.Return:
{
Return return_stmt = node as Return;
indent(shift);
Console.Write("return");
if (return_stmt.Expression != null)
{
Console.Write(" ");
report(return_stmt.Expression, 0);
}
Console.Write(";");
break;
}
case NodeType.Branch:
{
Branch branch = node as Branch;
indent(shift);
Console.WriteLine("break; (???)");
break;
}
case NodeType.For:
{
For for_stmt = node as For;
indent(shift);
Console.Write("for ( ");
for (int i = 0, n = for_stmt.Initializer.Length; i < n; i++)
{
report(for_stmt.Initializer[i], 0);
}
report(for_stmt.Condition, 0);
Console.Write("; ");
for (int i = 0, n = for_stmt.Incrementer.Length; i < n; i++)
{
report(for_stmt.Incrementer[i], 0);
}
Console.WriteLine(")");
indent(shift);
Console.WriteLine("{");
report(for_stmt.Body, shift + ind);
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.While:
{
While while_loop = node as While;
indent(shift);
Console.Write("while ( ");
report(while_loop.Condition, 0);
Console.WriteLine(" )");
report(while_loop.Body, shift);
break;
}
case NodeType.DoWhile:
{
DoWhile repeat = node as DoWhile;
indent(shift);
Console.WriteLine("do");
report(repeat.Body, shift);
indent(shift);
Console.Write("while (");
report(repeat.Condition, 0);
Console.WriteLine(" );");
break;
}
case NodeType.If:
{
If if_stmt = node as If;
indent(shift);
Console.Write("if ( ");
report(if_stmt.Condition, 0);
Console.WriteLine(" )");
report(if_stmt.TrueBlock, shift);
if (if_stmt.FalseBlock == null ||
if_stmt.FalseBlock.Statements == null ||
if_stmt.FalseBlock.Statements.Length == 0)
{
break;
}
indent(shift);
Console.WriteLine("else");
report(if_stmt.FalseBlock, shift);
break;
}
case NodeType.Switch:
{
Switch swtch = node as Switch;
indent(shift);
Console.Write("switch ( ");
report(swtch.Expression, 0);
Console.WriteLine(" )");
indent(shift);
Console.WriteLine("{");
for (int i = 0, n = swtch.Cases.Length; i < n; i++)
{
indent(shift + ind);
if (swtch.Cases[i].Label != null)
{
Console.Write("case ");
report(swtch.Cases[i].Label, 0);
Console.WriteLine(":");
}
else
{
Console.WriteLine("default:");
}
report(swtch.Cases[i].Body, shift + ind);
}
indent(shift);
Console.WriteLine("}");
break;
}
case NodeType.Throw:
{
Throw thro = node as Throw;
indent(shift);
Console.Write("throw (");
report(thro.Expression, 0);
Console.Write(");");
break;
}
case NodeType.Exit:
{
indent(shift);
Console.WriteLine("exit;");
break;
}
case NodeType.Continue:
{
indent(shift);
Console.WriteLine("continue;");
break;
}
case NodeType.Try:
{
Try trys = node as Try;
indent(shift);
Console.WriteLine("try {");
report(trys.TryBlock, shift + ind);
indent(shift);
Console.WriteLine("}");
if (trys.Catchers != null)
{
for (int i = 0, n = trys.Catchers.Length; i < n; i++)
{
indent(shift);
if (trys.Catchers[i].Type != null)
{
Console.Write("catch ( {0} ", trys.Catchers[i].Type.FullName);
}
else
{
Console.Write("catch ( ");
}
if (trys.Catchers[i].Variable != null)
{
report(trys.Catchers[i].Variable, 0);
}
Console.WriteLine(" ) {");
report(trys.Catchers[i].Block, shift + ind);
indent(shift);
Console.WriteLine("}");
}
}
if (trys.Finally != null && trys.Finally.Block != null)
{
indent(shift);
Console.WriteLine("finally");
report(trys.Finally.Block, shift);
}
break;
}
case NodeType.BlockExpression:
{
BlockExpression be = node as BlockExpression;
Console.WriteLine("(");
StatementList sl = be.Block.Statements;
for (int i = 0, n = sl.Length; i < n; i++)
{
report(sl[i], shift + ind);
}
indent(shift);
Console.Write(")");
break;
}
case NodeType.ArrayTypeExpression:
{
ArrayTypeExpression array = node as ArrayTypeExpression;
indent(shift);
if (array.ElementType != null &&
array.ElementType.Name != null &&
array.ElementType.Name.Name != null)
{
Console.Write(array.ElementType.Name.Name);
}
else
{
report(array.ElementType, 0);
}
Console.Write("[");
for (int i = 0, n = array.Rank; i < n; i++)
{
if (array.Sizes != null)
{
Console.Write(array.Sizes[i]);
}
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
break;
}
case NodeType.Construct:
{
Construct construct = node as Construct;
indent(shift);
Console.Write("new ");
report(construct.Constructor, 0);
Console.Write("(");
if (construct.Operands != null)
{
for (int i = 0, n = construct.Operands.Length; i < n; i++)
{
report(construct.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.Write(")");
break;
}
case NodeType.ConstructArray:
{
ConstructArray initializer = node as ConstructArray;
Console.Write("new ");
if (initializer.ElementType != null &&
initializer.ElementType.Name != null &&
initializer.ElementType.Name.Name != null)
{
Console.Write(initializer.ElementType.Name.Name);
}
else
{
report(initializer.ElementType, 0);
}
Console.Write("[");
for (int i = 0, n = initializer.Operands.Length; i < n; i++)
{
report(initializer.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
break;
}
case NodeType.ConstructDelegate:
{
ConstructDelegate cd = node as ConstructDelegate;
// Console.Write("new {0}({1})",cd.DelegateType.Name.Name,cd.MethodName.Name);
Console.Write("new {0}(", cd.DelegateType.Name.Name);
report(cd.TargetObject, 0);
Console.Write(".{0})", cd.MethodName.Name);
// cd.Type;
break;
}
default:
{
if (node is ZonnonCompilation)
{
ZonnonCompilation zc = node as ZonnonCompilation;
report(zc.CompilationUnits[0], shift);
}
// Expression?
else if (node is MethodCall)
{
MethodCall call = node as MethodCall;
report(call.Callee, 0);
Console.Write("(");
if (call.Operands != null && call.Operands.Length != 0)
{
for (int i = 0, n = call.Operands.Length; i < n; i++)
{
report(call.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
}
Console.Write(")");
}
else if (node is Variable)
{
Variable variable = node as Variable;
Console.Write("{0}", variable.Name.Name);
}
else if (node is Identifier)
{
Identifier identifier = node as Identifier;
Console.Write("{0}", identifier.Name);
}
else if (node is QualifiedIdentifier)
{
QualifiedIdentifier qualid = node as QualifiedIdentifier;
report(qualid.Qualifier, 0);
Console.Write(".{0}", qualid.Identifier == null?"<UNRESOLVED>":qualid.Identifier.Name);
}
else if (node is Literal)
{
Literal literal = node as Literal;
if (literal.Value == null)
{
Console.Write("null");
}
else
{
if (literal.Value is string)
{
Console.Write("\"");
}
else if (literal.Value is char)
{
Console.Write("'");
}
Console.Write("{0}", literal.Value.ToString());
if (literal.Value is string)
{
Console.Write("\"");
}
else if (literal.Value is char)
{
Console.Write("'");
}
}
}
else if (node is Indexer)
{
Indexer indexer = node as Indexer;
report(indexer.Object, 0);
Console.Write("[");
for (int i = 0, n = indexer.Operands.Length; i < n; i++)
{
report(indexer.Operands[i], 0);
if (i < n - 1)
{
Console.Write(",");
}
}
Console.Write("]");
}
else if (node is UnaryExpression)
{
UnaryExpression unexpr = node as UnaryExpression;
bool add_pars = unexpr.Operand is BinaryExpression ||
unexpr.Operand is UnaryExpression;
switch (unexpr.NodeType)
{
case NodeType.Add: Console.Write("+"); break;
case NodeType.Sub: Console.Write("-"); break;
case NodeType.Neg: Console.Write("-"); break;
case NodeType.Not: Console.Write("~"); break;
case NodeType.UnaryPlus: Console.Write("+"); break;
case NodeType.LogicalNot: Console.Write("!"); break;
case NodeType.Conv_U2: Console.Write("(UInt16)"); break;
case NodeType.RefAddress: Console.Write("ref "); break;
case NodeType.Ckfinite: Console.Write("(Ckfinite)"); break;
default: Console.Write("???"); break;
}
if (add_pars)
{
Console.Write("(");
}
report(unexpr.Operand, 0);
if (add_pars)
{
Console.Write(")");
}
}
else if (node is BinaryExpression)
{
BinaryExpression binexpr = node as BinaryExpression;
bool add_pars = binexpr.Operand1 is BinaryExpression ||
binexpr.Operand1 is UnaryExpression;
if (binexpr.NodeType == NodeType.Castclass)
{
Console.Write("(");
report(binexpr.Operand2, 0);
Console.Write(")");
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand1, 0);
if (add_pars)
{
Console.Write(")");
}
break;
}
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand1, 0);
if (add_pars)
{
Console.Write(")");
}
switch (binexpr.NodeType)
{
case NodeType.Add: Console.Write(" + "); break;
case NodeType.Add_Ovf: Console.Write(" + "); break;
case NodeType.Add_Ovf_Un: Console.Write(" + "); break;
case NodeType.Sub: Console.Write(" - "); break;
case NodeType.Sub_Ovf: Console.Write(" - "); break;
case NodeType.Sub_Ovf_Un: Console.Write(" - "); break;
case NodeType.Mul: Console.Write(" * "); break;
case NodeType.Mul_Ovf: Console.Write(" * "); break;
case NodeType.Mul_Ovf_Un: Console.Write(" * "); break;
case NodeType.Div: Console.Write(" / "); break;
// case NodeType.Div : Console.Write(" DIV "); break; // "DIV" ?????
case NodeType.Rem: Console.Write(" % "); break; // "MOD" ?????
case NodeType.Or: Console.Write(" | "); break;
case NodeType.And: Console.Write(" & "); break;
case NodeType.Eq: Console.Write(" == "); break;
case NodeType.Ne: Console.Write(" != "); break;
case NodeType.Lt: Console.Write(" < "); break;
case NodeType.Le: Console.Write(" <= "); break;
case NodeType.Gt: Console.Write(" > "); break;
case NodeType.Ge: Console.Write(" >= "); break;
case NodeType.LogicalOr: Console.Write(" || "); break;
case NodeType.LogicalAnd: Console.Write(" && "); break;
case NodeType.Is: Console.Write(" is "); break;
case NodeType.Comma: Console.Write(","); break;
// case OPERATORS.In : expression.NodeType = NodeType // "IN" break;
// case OPERATORS.Implements : expression.NodeType = NodeType // "IMPLEMENTS" break;
default: Console.Write(" !! "); break;
}
add_pars = binexpr.Operand2 is BinaryExpression ||
binexpr.Operand2 is UnaryExpression;
if (add_pars)
{
Console.Write("(");
}
report(binexpr.Operand2, 0);
if (add_pars)
{
Console.Write(")");
}
}
else if (node is TernaryExpression)
{
TernaryExpression ter = node as TernaryExpression;
if (ter.NodeType == NodeType.Conditional)
{
report(ter.Operand1, 0);
Console.Write(" ? ");
report(ter.Operand2, 0);
Console.Write(" : ");
report(ter.Operand3, 0);
}
}
else if (node is PostfixExpression)
{
PostfixExpression postfixExpr = node as PostfixExpression;
report(postfixExpr.Expression, 0);
switch (postfixExpr.Operator)
{
case NodeType.Increment: Console.Write("++"); break;
case NodeType.Decrement: Console.Write("--"); break;
default: Console.Write("???"); break;
}
}
else if (node is LabeledStatement)
{
LabeledStatement lbst = node as LabeledStatement;
indent(shift);
report(lbst.Label, 0);
Console.Write(" : ");
report(lbst.Statement, 0);
}
else if (node is Goto)
{
Goto gt = node as Goto;
indent(shift);
Console.Write("goto ");
report(gt.TargetLabel, 0);
}
else
{
indent(shift);
Console.WriteLine("No code for reporting {0}:{1}", node.UniqueKey, node.ToString());
}
break;
}
}
}
public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier1, QualifiedIdentifier qualifiedIdentifier2)
{
if (qualifiedIdentifier1 == null) return null;
if (qualifiedIdentifier2 == null)
qualifiedIdentifier1.Qualifier = this.VisitExpression(qualifiedIdentifier1.Qualifier, null);
else
qualifiedIdentifier1.Qualifier = this.VisitExpression(qualifiedIdentifier1.Qualifier, qualifiedIdentifier2.Qualifier);
return qualifiedIdentifier1;
}
public virtual Expression OnInvalidMemberBinding(MemberBinding mb, QualifiedIdentifier qualId){
return mb;
}
public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qi)
{
base.VisitQualifiedIdentifier(qi);
return((Expression)this.Compose(qi, this.GetComposer(qi.Qualifier)));
}
QualifiedIdentifier ConvertMemberName (MemberName memberName)
{
QualifiedIdentifier qi = new QualifiedIdentifier();
while (memberName != null) {
qi.InsertChildBefore (qi.FirstChild, new Identifier (memberName.Name, Convert (memberName.Location)), QualifiedIdentifier.Roles.Identifier);
memberName = memberName.Left;
}
return qi;
}
/**
* Returns the annotation's identifier.
*
* @return The annotation's identifier.
*/
public QualifiedIdentifier getIdentifier()
{
if (mIdentifier == null) {
mIdentifier = new AST2QualifiedIdentifier((AST2JSOMTree)
getTreeNode().GetChild(0), getTokenRewriteStream());
}
return mIdentifier;
}
/**
* If <code>this</code> represents an array type declarator for an array of
* any object type this method returns the appropriate type identifier.
*
* @see ArrayTypeDeclarator#getPrimitiveType()
*
* @return The type of the array elements or <code>null</code> if <code>
* 'isArrayOfPrimitiveType() == true'</code>.
*/
public QualifiedIdentifier getQualifiedIdentifier()
{
if (mIsArrayOfPrimitiveType) {
return null;
}
if (mQualifiedIdentifier == null) {
mQualifiedIdentifier = new AST2QualifiedIdentifier(
mTypeTree, getTokenRewriteStream());
}
return mQualifiedIdentifier;
}
public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier)
{
if (qualifiedIdentifier == null) return null;
return base.VisitQualifiedIdentifier((QualifiedIdentifier)qualifiedIdentifier.Clone());
}
public virtual MemberBinding GetMemberBinding(QualifiedIdentifier qualifiedIdentifier){
Member target = null;
TypeNode targetType = SystemTypes.Object;
Expression thisob = null;
if (qualifiedIdentifier == null) goto done;
NameBinding nb = qualifiedIdentifier.Qualifier as NameBinding;
MemberList members = this.GetMembers(qualifiedIdentifier);
Event e = null;
for (int i = 0, n = members.Count; i < n; i++){
target = members[i];
switch(target.NodeType){
case NodeType.Field:
Field f = (Field)target;
thisob = this.GetObject(qualifiedIdentifier);
if (f.IsStatic && thisob != null){
if (thisob.Type == SystemTypes.Type && thisob is Literal)
thisob = null;
else if (TypeNode.StripModifiers(thisob.Type) == f.DeclaringType){
if (nb != null && f.DeclaringType.Name != null && nb.Identifier.UniqueIdKey == f.DeclaringType.Name.UniqueIdKey) {
thisob = null;
}
}
}
targetType = f.Type;
goto done;
case NodeType.Property:
Property p = (Property)target;
if (p.ImplementedTypeExpressions != null && p.ImplementedTypeExpressions.Count > 0) {
target = null; continue;
}
Method g = p.Getter;
Method s = p.Setter;
if (g != null && g.Parameters != null && g.Parameters.Count != 0) continue;
if (s != null && (s.Parameters == null || s.Parameters.Count != 1)) continue;
thisob = this.GetObject(qualifiedIdentifier);
if (p.IsStatic && thisob != null && thisob.Type == SystemTypes.Type && thisob is Literal) thisob = null;
if (p.IsStatic && thisob != null){
if (thisob.Type == SystemTypes.Type && thisob is Literal)
thisob = null;
else if (TypeNode.StripModifiers(thisob.Type) == p.DeclaringType) {
if (nb != null && p.DeclaringType.Name != null && nb.Identifier.UniqueIdKey == p.DeclaringType.Name.UniqueIdKey) {
thisob = null;
}
}
}
targetType = p.Type;
goto done;
case NodeType.Method:
Method m = (Method)target;
if (m.ImplementedTypeExpressions != null && m.ImplementedTypeExpressions.Count > 0) {
target = null; continue;
}
thisob = this.GetObject(qualifiedIdentifier);
targetType = SystemTypes.Delegate;
qualifiedIdentifier.SourceContext = qualifiedIdentifier.Identifier.SourceContext;
goto done;
case NodeType.Event:
// Remember that we found an event, but don't return it yet in case there's
// also a field backing that event, in which case we want to return the field.
e = (Event)target;
break;
}
}
if (e != null){
if (!e.IsStatic) thisob = this.GetObject(qualifiedIdentifier);
targetType = e.HandlerType;
goto done;
}
if (target != null){
thisob = qualifiedIdentifier.Qualifier;
targetType = SystemTypes.Void;
qualifiedIdentifier.SourceContext = qualifiedIdentifier.Identifier.SourceContext;
}
done:
if (target == null) return null;
MemberBinding result = new MemberBinding(thisob, target, qualifiedIdentifier.Identifier);
result.Type = targetType;
result.SourceContext = qualifiedIdentifier.SourceContext;
qualifiedIdentifier.BoundMember = result;
return result;
}
public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier){
if (qualifiedIdentifier == null) return null;
qualifiedIdentifier.Qualifier = this.VisitExpression(qualifiedIdentifier.Qualifier);
return qualifiedIdentifier;
}
public virtual Expression OnInvalidQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier, Identifier id){
return qualifiedIdentifier;
}
/**
* Call back method that must be called as soon as the given <code>
* QualifiedIdentifier</code> object has been traversed.
*
* @param pQualifiedIdentifier The <code>QualifiedIdentifier</code> object
* that has just been traversed.
*/
public void actionPerformed(
QualifiedIdentifier pQualifiedIdentifier)
{
// Nothing to do.
}
public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier) {
//At this stage, the only way a quantified identifier can exist without the program being in error is
//when the reference is to a modelfield of a class C that was inherited from an interface, but not implemented explicity by C
//TODO: Check if this is the case, and resolve the qualified identifier to a memberbinding.
//Otherwise:
//Report the error and remove this node from the tree
if (qualifiedIdentifier == null) return null;
NameBinding nb = qualifiedIdentifier.Qualifier as NameBinding;
if (nb != null) {
MemberList boundMembers = nb.BoundMembers;
TypeNode t = null;
for (int i = 0, n = boundMembers == null ? 0 : boundMembers.Count; i < n; i++) {
t = boundMembers[i] as TypeNode;
if (t != null) {
this.HandleError(nb.Identifier, Error.TypeNotAccessible, this.GetTypeName(t));
return null;
}
}
this.HandleError(nb.Identifier, Error.NoSuchType, nb.Identifier.ToString());
return null;
}
Expression qualifier = this.VisitExpression(qualifiedIdentifier.Qualifier);
if (qualifier == null) return null; //An error has been reported on the qualifier. Do not compound it.
TypeNode qtype = qualifier.Type;
if (qtype == null) return null; //ditto
if (qtype.Name == Looker.NotFound) return null; //ditto
if (qtype == SystemTypes.Type) {
Literal lit = qualifier as Literal;
if (lit != null && lit.Value is TypeNode)
qtype = lit.Value as TypeNode;
else {
MemberBinding mb = qualifier as MemberBinding;
if (mb != null && mb.BoundMember is TypeNode)
qtype = mb.BoundMember as TypeNode;
}
if (qtype == null) return null;
}
qtype = this.typeSystem.Unwrap(qtype);
this.HandleError(qualifiedIdentifier.Identifier, Error.NoSuchMember, this.GetTypeName(qtype), qualifiedIdentifier.Identifier.ToString());
return null;
}
public InvokeExpression(QualifiedIdentifier methodName, IList <Argument> arguments, bool isStatementExpression)
{
MethodName = methodName;
Arguments = arguments;
IsStatementExpression = isStatementExpression;
}
/**
* Call back method that must be called when the given <code>
* QualifiedIdentifier</code> will become the next <i>traverse
* candidate</i>.
*
* @param pQualifiedIdentifier The <code>QualifiedIdentifier</code> object
* that will become the next <i>traverse
* candidate</i>.
*/
public void performAction(
QualifiedIdentifier pQualifiedIdentifier)
{
// Nothing to do.
}
public virtual void VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier)
{
if (qualifiedIdentifier == null) return;
this.VisitExpression(qualifiedIdentifier.Qualifier);
}
public virtual Differences VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier1, QualifiedIdentifier qualifiedIdentifier2){
Differences differences = new Differences(qualifiedIdentifier1, qualifiedIdentifier2);
if (qualifiedIdentifier1 == null || qualifiedIdentifier2 == null){
if (qualifiedIdentifier1 != qualifiedIdentifier2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QualifiedIdentifier changes = (QualifiedIdentifier)qualifiedIdentifier2.Clone();
QualifiedIdentifier deletions = (QualifiedIdentifier)qualifiedIdentifier2.Clone();
QualifiedIdentifier insertions = (QualifiedIdentifier)qualifiedIdentifier2.Clone();
Differences diff = this.VisitIdentifier(qualifiedIdentifier1.Identifier, qualifiedIdentifier2.Identifier);
if (diff == null){Debug.Assert(false); return differences;}
changes.Identifier = diff.Changes as Identifier;
deletions.Identifier = diff.Deletions as Identifier;
insertions.Identifier = diff.Insertions as Identifier;
Debug.Assert(diff.Changes == changes.Identifier && diff.Deletions == deletions.Identifier && diff.Insertions == insertions.Identifier);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitExpression(qualifiedIdentifier1.Qualifier, qualifiedIdentifier2.Qualifier);
if (diff == null){Debug.Assert(false); return differences;}
changes.Qualifier = diff.Changes as Expression;
deletions.Qualifier = diff.Deletions as Expression;
insertions.Qualifier = diff.Insertions as Expression;
Debug.Assert(diff.Changes == changes.Qualifier && diff.Deletions == deletions.Qualifier && diff.Insertions == insertions.Qualifier);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public Maybe<ISymbol> Resolve(QualifiedIdentifier identifier, SymbolTable table)
{
return table.Resolve(FullName + identifier)
.Or(() => Parent.OfType<IResolutionRoot>().SelectMaybe(x => x.Resolve(identifier, table)));
}
/**
* Returns the import path of the import declaration.
* <p>
* Note that for <i>multi imports</i> the returned qualified identifier
* doesn't contain the star stated at the end of the import path within the
* Java source.
*
* @see ImportDeclaration#isMultiImport()
*
* @return The import path.
*/
public QualifiedIdentifier getPackagePath()
{
if (mIdentifier == null) {
AST2JSOMTree tree = (AST2JSOMTree)getTreeNode();
AST2JSOMTree idChild = (AST2JSOMTree)tree.GetChild(0);
if (idChild.Type == JavaTreeParser.STATIC) {
idChild = (AST2JSOMTree)tree.GetChild(1);
}
mIdentifier = new AST2QualifiedIdentifier(
idChild, getTokenRewriteStream());
}
return mIdentifier;
}
public virtual Expression GetContextBinding(NameBinding nameBinding){
if (nameBinding == null) return null;
bool savedCR = this.hasContextReference;
QueryContext qc = new QueryContext();
qc.SourceContext = nameBinding.SourceContext;
for (ContextScope scope = this.contextScope; scope != null; scope = scope.Previous){
qc.Type = scope.Type;
qc.Scope = scope;
QualifiedIdentifier qi = new QualifiedIdentifier(qc, nameBinding.Identifier);
Expression result = this.VisitQualifiedIdentifier(qi);
if (result != null && result != qi){
result.SourceContext = nameBinding.SourceContext;
return result;
}
}
this.hasContextReference = savedCR;
return null;
}
public NamespaceSyntax(QualifiedIdentifier name, IEnumerable<QualifiedIdentifier> usings, IEnumerable<INamespaceSyntaxMember> members)
{
Name = Guard.NotNull(name, "name");
Usings = Guard.NotNull(usings, "usings");
Members = Guard.NotNull(members, "members");
}
public virtual Expression VisitQualifiedIdentifierCore(QualifiedIdentifier qualifiedIdentifier){
MemberBinding result = this.GetMemberBinding(qualifiedIdentifier);
return result;
}
public override string ToString()
{
return(QualifiedIdentifier.ToString());
}
protected virtual MemberList GetMembers(int line, int col, QualifiedIdentifier qualId, Scope scope) {
if (qualId == null) return null;
bool staticMembersWanted = true;
bool allMembersWanted = false;
Node n = qualId.Qualifier;
if (n == null || n.IsErroneous) return null;
if (n is ConstructArray) return null;
TypeNode type = null;
MemberBinding mb = this.GetMemberBinding(n);
if (mb != null){
staticMembersWanted = false;
Member mem = mb.BoundMember;
if (mem is Field)
type = ((Field)mem).Type;
else if (mem is Property)
type = ((Property)mem).Type;
else if (mem is InstanceInitializer)
type = mem.DeclaringType;
//TODO: other stuff? Events?
allMembersWanted = (mem != null && type != null && mem.Name != null && type.Name != null && mem.Name.UniqueIdKey == type.Name.UniqueIdKey);
}else{
if (n is Identifier || n is NameBinding || n is QualifiedIdentifier){
NameBinding nb = n as NameBinding;
if (nb != null) n = nb.Identifier;
return this.languageService.GetNestedNamespacesAndTypes(this.ConvertToNamespaceId((Expression)n), scope);
}
type = n as TypeNode;
if (type == null){
if (n is Literal){
if (Literal.IsNullLiteral((Literal)n)) return null;
type = ((Literal)n).Value as TypeNode;
}
Expression expr = n as Expression;
if (type == null && expr != null){
if (n is Base && n.SourceContext.Document == null) return null;
staticMembersWanted = false;
type = expr.Type;
MethodCall mc = expr as MethodCall;
bool useEnum = false;
if (mc != null && mc.Callee is MemberBinding) {
Member mem = ((MemberBinding)mc.Callee).BoundMember;
Method meth = mem as Method;
if (meth != null) {
Property p = meth.DeclaringMember as Property;
useEnum = p == null;
allMembersWanted = p != null && type != null && p.Name != null && type.Name != null && p.Name.UniqueIdKey == type.Name.UniqueIdKey;
}
}
if (type is EnumNode && useEnum) type = SystemTypes.Enum;
}
}
}
TypeAlias ta = type as TypeAlias;
while (ta != null) {
type = ta.AliasedType;
ta = type as TypeAlias;
}
type = TypeNode.StripModifiers(type);
if (type is Reference) type = ((Reference)type).ElementType;
if (type == null || type == SystemTypes.Void) return null;
TypeNode referringType = null;
while (scope != null){
TypeScope tScope = scope as TypeScope;
if (tScope != null){
referringType = tScope.Type;
break;
}
scope = scope.OuterScope;
}
Debug.Assert(referringType != SystemTypes.Object);
MemberList result = new MemberList();
bool showPrivate = referringType == type;
bool showFamily = referringType == null || type.IsAssignableTo(referringType) || n is Base;
bool showInternal = this.MayAccessInternals(referringType, type);
this.GetMembers(type, result, staticMembersWanted, allMembersWanted, showPrivate, showFamily, showInternal);
return result;
}
public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier, QualifiedIdentifier changes, QualifiedIdentifier deletions, QualifiedIdentifier insertions){
this.UpdateSourceContext(qualifiedIdentifier, changes);
if (qualifiedIdentifier == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qualifiedIdentifier;
}
public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier)
{
throw new ApplicationException("unimplemented");
}
