[svn] r7788: nemerle/trunk/ncc: hierarchy/GlobalEnv.n
typing/Typer-DelayedTyping.n typing/Typer.n
nazgul
svnadmin at nemerle.org
Thu Sep 6 11:54:37 CEST 2007
Log:
Fix for using type alias to generic types in bug 1029. Patch by BOleg
Author: nazgul
Date: Thu Sep 6 11:54:35 2007
New Revision: 7788
Modified:
nemerle/trunk/ncc/hierarchy/GlobalEnv.n
nemerle/trunk/ncc/typing/Typer-DelayedTyping.n
nemerle/trunk/ncc/typing/Typer.n
Modified: nemerle/trunk/ncc/hierarchy/GlobalEnv.n
==============================================================================
--- nemerle/trunk/ncc/hierarchy/GlobalEnv.n (original)
+++ nemerle/trunk/ncc/hierarchy/GlobalEnv.n Thu Sep 6 11:54:35 2007
@@ -271,30 +271,39 @@
}
}
+ public LookupSymbol (name : list [string], parent : TypeBuilder,
+ for_completion = false) : list[IMember]
+ {
+ List.FoldLeft(LookupSymbolExt(name, parent, for_completion), [], fun((_, m), acc) {
+ if(List.Contains(acc, m)) acc else m :: acc
+ });
+ }
+
- public LookupSymbol (name : list [string], _parent : TypeBuilder,
- for_completion = false) : list [IMember]
+ public LookupSymbolExt (name : list [string], parent : TypeBuilder,
+ for_completion = false) : list[TypeInfo * IMember]
{
// these are really small, so we do linear lookup in list
mutable visited = [];
def (type_part, the_name) = List.DivideLast (name);
// now we have type_part . the_name
- def add_members_from (t : TypeInfo, acc) {
- if (List.ContainsRef(visited, t))
+ def add_members_from ((pt : TypeInfo, ti : TypeInfo), acc : list[TypeInfo * IMember]) {
+ if (List.Contains(visited, (pt, ti)))
acc
else {
def members =
- if (t.LookupMemberAvailable)
- t.LookupMember (the_name, for_completion)
+ if (ti.LookupMemberAvailable)
+ ti.LookupMember (the_name, for_completion)
else [];
- visited = t :: visited;
+ visited = (pt, ti) :: visited;
def acc =
members.FoldLeft (acc, fun (mem, acc) {
- if (List.ContainsRef (acc, mem)) acc else mem :: acc
+ if (List.Contains (acc, (pt, mem))) acc else (pt, mem) :: acc
});
- match (t.GetTydecl ()) {
- | TypeDeclaration.Alias (MType.Class (ti, _)) => add_members_from (ti, acc)
+ match (ti.GetTydecl ()) {
+ | TypeDeclaration.Alias (MType.Class (ati, args)) when (args.Length==0) => add_members_from ((pt, ati), acc)
+ | TypeDeclaration.Alias (MType.Class (ati, args)) when (args.Length>0) => add_members_from ((ti, ati), acc)
| _ => acc
}
}
@@ -302,30 +311,30 @@
mutable type_node = null;
- def lookup_members (pref : NamespaceTree.Node, mutable acc) {
+ def lookup_members (pref : NamespaceTree.Node, mutable acc : list[TypeInfo * IMember]) {
// do not lookup members in base classes
// (type_node is non-null when searching them in code below)
// they are already correctly added in add_members_from
when (type_node == null || !type_part.IsEmpty)
foreach (ti in pref.LookupTypes (type_part))
- acc = add_members_from (ti, acc);
+ acc = add_members_from ((null, ti), acc);
foreach (t : IMember in pref.LookupTypes (name, for_completion))
- when (!List.ContainsRef (acc, t))
- acc ::= t;
+ when (!List.Contains (acc, (null, t)))
+ acc ::= (null, t);
acc
};
mutable result = List.FoldLeft (nameTree.namespace_tree :: open_namespaces, [], lookup_members);
- mutable ns_node = if (_parent == null) null else _parent.NamespaceNode;
+ mutable ns_node = if (parent == null) null else parent.NamespaceNode;
while (ns_node != null) {
result = lookup_members (ns_node, result);
ns_node = ns_node.Parent;
}
// collect in types from inside of base classes
- type_node = if (_parent == null) null else _parent.BaseType;
+ type_node = if (parent == null) null else parent.BaseType;
while (type_node != null) {
result = lookup_members (type_node.NamespaceNode, result);
type_node = type_node.BaseType
Modified: nemerle/trunk/ncc/typing/Typer-DelayedTyping.n
==============================================================================
--- nemerle/trunk/ncc/typing/Typer-DelayedTyping.n (original)
+++ nemerle/trunk/ncc/typing/Typer-DelayedTyping.n Thu Sep 6 11:54:35 2007
@@ -579,7 +579,7 @@
def loop (ti : TypeInfo) {
foreach (meth is IMethod in ti.LookupMember (name))
when (meth.IsStatic)
- res = typer.ConstructMethodOverload (meth) + res;
+ res = typer.ConstructMethodOverload (ti, meth) + res;
match (ti.GetTydecl ()) {
| TypeDeclaration.Interface =>
loop (InternalType.Object_tc)
@@ -767,11 +767,11 @@
| Kind.Operator (t1, t2, name, env) =>
def operators = {
- def globals = env.LookupSymbol ([name], typer.current_type);
+ def globals = env.LookupSymbolExt ([name], typer.current_type);
mutable res = [];
- foreach (meth is IMethod in globals)
+ foreach ((ti, meth) in globals)
when (meth.IsStatic)
- res = typer.ConstructMethodOverload (meth) + res;
+ res = typer.ConstructMethodOverload (ti, meth :> IMethod) + res;
when (LookupOperator (t1, name) is Some (lst))
res = lst + res;
when (LookupOperator (t2, name) is Some (lst))
Modified: nemerle/trunk/ncc/typing/Typer.n
==============================================================================
--- nemerle/trunk/ncc/typing/Typer.n (original)
+++ nemerle/trunk/ncc/typing/Typer.n Thu Sep 6 11:54:35 2007
@@ -855,7 +855,7 @@
match (res) {
| [one] =>
- def overload = ConstructMethodOverload (one).Head;
+ def overload = ConstructMethodOverload (null, one).Head;
method = overload.Compile () :> TExpr.StaticRef;
def ok = method.Type.Require (needed);
Util.cassert (ok);
@@ -2395,7 +2395,7 @@
}
- ConstructEnclosingType (pt_from : PT.PExpr, symbol : IMember,
+ ConstructEnclosingType (pt_from : PT.PExpr, ti : TypeInfo, symbol : IMember,
additional_sig_types : list [MType] = null) : MType.Class
{
if (pt_from != null) {
@@ -2405,14 +2405,22 @@
ReportError (messenger, $ "$pt_from is not a class type");
InternalType.Object
}
- } else if (InCurrentType (symbol) &&
- symbol.DeclaringType.TyparmsCount <= current_type.TyparmsCount) {
- def typarms_count = symbol.DeclaringType.TyparmsCount;
+ } else {
+ def declaring = if(ti == null) symbol.DeclaringType else ti;
+
+ if (InCurrentType (symbol) &&
+ declaring.TyparmsCount <= current_type.TyparmsCount) {
+ def typarms_count = declaring.TyparmsCount;
def typarms = current_type.GetMemType ().args.FirstN (typarms_count);
- MType.Class (symbol.DeclaringType, typarms)
+ MType.Class (declaring, typarms)
} else {
- def declaring = symbol.DeclaringType;
- def from = declaring.GetFreshType ();
+
+ def from =
+ match(declaring.GetTydecl())
+ {
+ | TypeDeclaration.Alias (MType.Class (ati, args)) => MType.Class(ati, args)
+ | _ => declaring.GetFreshType ()
+ }
unless (declaring.Typarms.IsEmpty) {
def type_tyvars = Hashtable ();
@@ -2456,14 +2464,15 @@
from
}
}
+ }
- public ConstructMethodOverload (m : IMethod, pt_from : PT.PExpr = null,
+ public ConstructMethodOverload (ti : TypeInfo, m : IMethod, pt_from : PT.PExpr = null,
maybe_varargs = false) : list [OverloadPossibility]
{
def bounds = m.GetHeader ().typarms.Map (fun (tv) { tv.LowerBound });
def make_overload () {
- def from = ConstructEnclosingType (pt_from, m, bounds);
+ def from = ConstructEnclosingType (pt_from, ti, m, bounds);
def (ty, vars) = from.TypeOfMethodWithTyparms (m);
OverloadPossibility (this, ty, null, from, m,
@@ -2481,11 +2490,11 @@
}
- InterpretGlobal (pt_from : PT.PExpr, symbol : IMember) : list [OverloadPossibility]
+ InterpretGlobal (pt_from : PT.PExpr, ti : TypeInfo, symbol : IMember) : list [OverloadPossibility]
{
def single (mem) {
//Message.Debug ($"access of $mem");
- def from = ConstructEnclosingType (pt_from, mem);
+ def from = ConstructEnclosingType (pt_from, ti, mem);
[OverloadPossibility (this, from.TypeOfMember (mem), null, from, mem)]
}
@@ -2521,7 +2530,7 @@
TypeToConstructor (pt_from, mem :> TypeInfo)
| MemberKinds.Method | MemberKinds.Constructor =>
- ConstructMethodOverload (mem :> IMethod, pt_from, maybe_varargs = true)
+ ConstructMethodOverload (ti, mem :> IMethod, pt_from, maybe_varargs = true)
| MemberKinds.Property
| MemberKinds.Field =>
@@ -2542,16 +2551,16 @@
InterpretGlobals (pt_from : PT.PExpr,
- symbols : list [IMember],
+ globals : list [TypeInfo * IMember],
expected : TyVar,
dump_errors : bool)
: list [OverloadPossibility]
{
mutable res = [];
- foreach (symbol in symbols) {
+ foreach ((ti, symbol) in globals) {
if (dump_errors) {
- foreach (op in InterpretGlobal (pt_from, symbol)) {
+ foreach (op in InterpretGlobal (pt_from, ti, symbol)) {
try {
solver.PushState ();
messenger.NeedMessage = true;
@@ -2564,12 +2573,12 @@
def not_ok =
try {
solver.PushState ();
- InterpretGlobal (pt_from, symbol).IsEmpty;
+ InterpretGlobal (pt_from, ti, symbol).IsEmpty;
} finally {
solver.PopState ();
}
unless (not_ok)
- foreach (op in InterpretGlobal (pt_from, symbol)) {
+ foreach (op in InterpretGlobal (pt_from, ti, symbol)) {
def ok =
try {
solver.PushState ();
@@ -2582,7 +2591,6 @@
}
}
}
-
res
}
@@ -2700,7 +2708,7 @@
lookup (possible_type);
foreach (meth in Manager.LibrariesManager.GetExtensionMethods (name.Id, name.GetEnv (env), false))
- foreach (over in ConstructMethodOverload (meth, maybe_varargs = true)) {
+ foreach (over in ConstructMethodOverload (null, meth, maybe_varargs = true)) {
over.ExtensionMethodObject = obj;
res ::= over;
}
@@ -2857,8 +2865,8 @@
if (pt_from == null)
match (Util.QidOfExpr (expr)) {
| Some ((idl, name)) =>
- name.GetEnv (env).LookupSymbol (idl, current_type,
- for_completion)
+ name.GetEnv (env).LookupSymbolExt (idl, current_type,
+ for_completion);
| None =>
// oops
match (expr) {
@@ -2872,7 +2880,7 @@
else
match (current_type.BindType (pt_from).Fix ()) {
| MType.Class (tc, _) =>
- tc.LookupMember (mem_name, for_completion)
+ List.FoldLeft(tc.LookupMember (mem_name, for_completion), [], fun(x, acc) { (null, x) :: acc});
| _ =>
ReportError (messenger, $ "$pt_from is not a class type");
[]
More information about the svn
mailing list