Global names have no longer always uid == 0

uid == 0 is reserved for the Prelude to allow code generation and translation to have a simple construction of True, False etc.

For all other modules a single uid is defined for the global bindings in that module.
All instances and classes use the same uid as the one defined for the class in question. This is not fully implemented in the Renamer as of now

Author: Marwes

compiler.rs

@@ -604,7 +604,7 @@ impl <'a> Compiler<'a> {
                         }
                         else {
                             let fromInteger = Identifier(Id {
-                                name: Name { name: intern("fromInteger"), uid: 999999 }, 
+                                name: Name { name: intern("fromInteger"), uid: 0 }, 
                                 typ: qualified(~[], function_type_(int_type(), literal.typ.clone())),
                             });
                             let number = Literal(Literal { typ: int_type(), value: Integral(i) });
@@ -618,7 +618,7 @@ impl <'a> Compiler<'a> {
                         }
                         else {
                             let fromRational = Identifier(Id {
-                                name: Name { name: intern("fromRational"), uid: 999999 }, 
+                                name: Name { name: intern("fromRational"), uid: 0 }, 
                                 typ: qualified(~[], function_type_(double_type(), literal.typ.clone())),
                             });
                             let number = Literal(Literal {
@@ -810,7 +810,7 @@ impl <'a> Compiler<'a> {
                 let mut b = String::from_str("#");
                 b.push_str(typename);
                 b.push_str(name.as_slice());
-                let instance_fn_name = Name { name: intern(b.as_slice()), uid: 0 };
+                let instance_fn_name = Name { name: intern(b.as_slice()), uid: name.uid };
                 match self.find(instance_fn_name) {
                     Some(GlobalVariable(index)) => {
                         instructions.push(PushGlobal(index));
@@ -979,7 +979,7 @@ impl <'a> Compiler<'a> {
                     b.push_str(x.name.as_slice());
                     b.push_str(decl.name.as_slice());
                     let f = intern(b.as_slice());
-                    let name = Name { name: f, uid: 0 };
+                    let name = Name { name: f, uid: decl.name.uid };
                     match self.find(name) {
                         Some(GlobalVariable(index)) => {
                             function_indexes.push(index as uint);

core.rs

@@ -515,8 +515,8 @@ pub mod translate {
                 //Example stub for undeclared (/=)
                 //(/=) = #Eq/=
                 Binding {
-                    name: Id::new(Name { name: instance_fn_name, uid: 0 }, typ.clone(), constraints.clone()),
-                    expression: Identifier(Id::new(Name { name: default_name, uid: 0 }, typ, constraints))
+                    name: Id::new(Name { name: instance_fn_name, uid: decl.name.uid }, typ.clone(), constraints.clone()),
+                    expression: Identifier(Id::new(Name { name: default_name, uid: decl.name.uid }, typ, constraints))
                 }
             })
             .collect()

renamer.rs

@@ -53,7 +53,7 @@ pub struct NameSupply {
 impl NameSupply {
 
     pub fn new() -> NameSupply {
-        NameSupply { unique_id: 0 }
+        NameSupply { unique_id: 1 }
     }
     ///Create a unique Name which are anonymous
     pub fn anonymous(&mut self) -> Name {
@@ -75,6 +75,11 @@ impl NameSupply {
 
 ///The renamer has methods which turns the ASTs identifiers from simple strings
 ///into unique Names
+///Currently there is some constraints on what the unique ids should be.
+///Each module gets one uid which it uses for a top level declarations (bindings, types, etc)
+///All functions which are in a class or an instance gets the same id as the class has,
+///this is to allow the compiler to find the specific instance/class functions when it constructs dictionaries
+///All uid's of the other names can have any uid (as long as it introduces no name collisions)
 struct Renamer {
     ///Mapping of strings into the unique name
     uniques: ScopedMap<InternedStr, Name>,
@@ -88,27 +93,19 @@ impl Renamer {
         Renamer { uniques: ScopedMap::new(), name_supply: NameSupply::new(), errors: Errors::new() }
     }
 
-    fn insert_globals(&mut self, module: &Module<InternedStr>) {
-        for ctor in module.dataDefinitions.iter().flat_map(|data| data.constructors.iter()) {
-            self.make_unique(ctor.name.clone());
-        }
-        for newtype in module.newtypes.iter() {
-            self.make_unique(newtype.constructor_name.clone());
-        }
-        for bind in module.instances.iter().flat_map(|instance| binding_groups(instance.bindings.as_slice())) {
-            self.make_unique(bind[0].name.clone());
-        }
-        for class in module.classes.iter() {
-            self.make_unique(class.name);
-            for decl in class.declarations.iter() {
-                self.make_unique(decl.name.clone());
-            }
-            for bind in binding_groups(class.bindings) {
-                self.make_unique(bind[0].name.clone());
-            }
-        }
-        for bind in binding_groups(module.bindings.as_slice()) {
-            self.make_unique(bind[0].name.clone());
+    fn insert_globals(&mut self, module: &Module<InternedStr>, uid: uint) {
+        let mut names = module.dataDefinitions.iter()
+            .flat_map(|data| data.constructors.iter().map(|ctor| ctor.name))
+            .chain(module.newtypes.iter().map(|newtype| newtype.constructor_name))
+            .chain(module.instances.iter()
+                .flat_map(|instance| binding_groups(instance.bindings.as_slice()).map(|binds| binds[0].name)))
+            .chain(module.classes.iter().flat_map(|class|
+                Some(class.name).move_iter()
+                .chain(class.declarations.iter().map(|decl| decl.name))
+                .chain(binding_groups(class.bindings).map(|binds| binds[0].name))))
+            .chain(binding_groups(module.bindings.as_slice()).map(|binds| binds[0].name));
+        for name in names {
+            self.declare_global(name, uid);
         }
     }
 
@@ -269,6 +266,12 @@ impl Renamer {
             u
         }
     }
+    fn declare_global(&mut self, s: InternedStr, module_id: uint) -> Name {
+        self.make_unique(s);
+        let name = self.uniques.find_mut(&s).unwrap();
+        name.uid = module_id;
+        *name
+    }
 }
 
 pub fn rename_expr(expr: TypedExpr<InternedStr>) -> TypedExpr<Name> {
@@ -281,9 +284,14 @@ pub fn rename_module(module: Module<InternedStr>) -> Module<Name> {
     rename_module_(&mut renamer, module)
 }
 pub fn rename_module_(renamer: &mut Renamer, module: Module<InternedStr>) -> Module<Name> {
-    renamer.insert_globals(&module);
+    let mut name = renamer.make_unique(module.name);
+    if name.as_slice() == "Prelude" {
+        renamer.uniques.find_mut(&name.name).unwrap().uid = 0;
+        name.uid = 0;
+    }
+    renamer.insert_globals(&module, name.uid);
     let Module {
-        name: name,
+        name: _,
         imports: imports,
         classes : classes,
         dataDefinitions: data_definitions,
@@ -405,7 +413,7 @@ pub fn rename_module_(renamer: &mut Renamer, module: Module<InternedStr>) -> Mod
         .collect();
 
     Module {
-        name: renamer.make_unique(name),
+        name: name,
         imports: FromVec::from_vec(imports2),
         classes : FromVec::from_vec(classes2),
         dataDefinitions: FromVec::from_vec(data_definitions2),

vm.rs

@@ -960,23 +960,25 @@ fn import() {
 
 #[test]
 fn pattern_bind() {
-    let result = execute_main(
-r"data Bool = True | False
+    let result = execute_main_string(
+r"
+import Prelude
 
 test :: [Bool] -> Bool
 test (True:[]) = False
 test (True:y:ys) = y
 test [] = False
 
 main = test [True, True]
-".chars());
+")
+    .unwrap_or_else(|err| fail!(err));
     assert_eq!(result, Some(ConstructorResult(0, Vec::new())));
 }
 #[test]
 fn pattern_guards() {
-    let result = execute_main(
+    let result = execute_main_string(
 r"
-data Bool = True | False
+import Prelude
 
 test :: Int -> [a] -> Int
 test 2 _ = 2
@@ -987,15 +989,16 @@ test x _ = x
 
 main = (test 2 [], test 100 [], test 100 ['c'])
 
-".chars());
+")
+    .unwrap_or_else(|err| fail!(err));
     assert_eq!(result, Some(ConstructorResult(0, vec!(IntResult(2), IntResult(1), IntResult(100)))));
 }
 
 #[test]
 fn pattern_guards_nested() {
-    let result = execute_main(
+    let result = execute_main_string(
 r"
-data Bool = True | False
+import Prelude
 
 test :: Int -> [Int] -> Int
 test 2 _ = 2
@@ -1006,7 +1009,8 @@ test x _ = x
 
 main = (test 2 [], test 100 [0], test 100 [0, 123])
 
-".chars());
+")
+    .unwrap_or_else(|err| fail!(err));
     assert_eq!(result, Some(ConstructorResult(0, vec!(IntResult(2), IntResult(1), IntResult(100)))));
 }
 #[test]