--- a/sema/ScopeBuilder.d	Sat Jun 21 17:32:27 2008 +0200
+++ b/sema/ScopeBuilder.d	Sat Jun 21 20:41:18 2008 +0200
@@ -4,7 +4,8 @@
        tango.core.Array : find;
 
 public
-import sema.Scope;
+import sema.Scope,
+       sema.Symbol;
 
 import sema.Visitor,
        basic.SmallArray;
@@ -14,19 +15,31 @@
     override void visit(Module[] modules)
     {
         this.modules = modules;
-        super.visit(modules);
+        inFunctionBodyStack.push(false);
+        foreach (mod; modules)
+        {
+            current = mod;
+            foreach (decl; mod.decls)
+                visitDecl(decl);
+        }
     }
 
     override void visitFuncDecl(FuncDecl d)
     {
+
         visitExp(d.returnType);
         visitExp(d.identifier);
         foreach (arg; d.funcArgs)
             visitDecl(arg);
+
+        inFunctionBodyStack.push(true);
+
         foreach (stmt; d.statements)
             visitStmt(stmt);
 
-        d.env.find(d.identifier).setType(d.type);
+        inFunctionBodyStack.pop();
+
+        d.sym = current.symbol.createMember(d.identifier.get, d.type);
     }
 
     override void visitVarDecl(VarDecl d)
@@ -37,35 +50,68 @@
         if (d.init)
             visitExp(d.init);
 
-        d.env.find(d.identifier).setType( typeOf(d.varType, d.env) );
+        DType t = typeOf(d.varType, d.env);
+        /*
+        if (inFunctionBodyStack.peek())
+        {
+            Stdout.formatln("?? {}, {}, {}", d.varType.get, d.identifier.get, t);
+            auto find = d.env.find(d.varType);
+            d.sym = d.env.find(d.varType).sym;
+        }
+        else
+        */
+            d.sym = current.symbol.createMember(d.identifier.get, t);
     }
 
     override void visitStructDecl(StructDecl s)
     {
-        super.visitStructDecl(s);
+        auto st = s.env.findType(s.identifier).asStruct;
+        s.sym = current.symbol.createMember(s.identifier.get, st);
+        //s.env.set(s.identifier, s);
 
-        DType[char[]] types;
+        auto old = current.symbol;
+        current.symbol = s.sym;
+        inFunctionBodyStack.push(false);
+        super.visitStructDecl(s);
+        inFunctionBodyStack.pop();
+        current.symbol = old;
 
-        auto st = s.env.types[s.identifier.get].asStruct;
         foreach (decl; s.decls)
+        {
+            DType type;
+            char[] name;
             if (auto varDecl = cast(VarDecl)decl)
-                st.addMember(typeOf(varDecl.varType, varDecl.env), varDecl.identifier.get);
+            {
+                type = typeOf(varDecl.varType, varDecl.env);
+                name = varDecl.identifier.get;
+            }
             else if (auto fd = cast(FuncDecl)decl)
-                st.addMember(fd.type, fd.identifier.get);
+            {
+                type = fd.type;
+                name = fd.identifier.get;
+            }
+            st.addMember(type, name);
+        }
     }
 
     DType typeOf(Identifier id, Scope sc)
     {
         if(auto i = cast(PointerIdentifier)id)
             return (typeOf(i.pointerOf, sc)).getPointerTo();
-        if(auto i = cast(ArrayIdentifier)id)
+        else if(auto i = cast(ArrayIdentifier)id)
             return typeOf(i.arrayOf, sc).getAsArray(i.size);
         return sc.findType(id);
     }
 
     Module[] modules;
+    Module current;
+    SmallArray!(bool) inFunctionBodyStack;
 }
 
+/**
+  Add scopes to everything, and add all identifiers that correspond to types.
+  Types/Symbols are added by ForwardReference.
+ **/
 class ScopeBuilder : Visitor!(void)
 {
     static ModuleHandler mHandle;
@@ -89,26 +135,43 @@
         fr.visit(modules);
     }
 
+    private void registerBasicTypeTo(char[] n, DType t, Scope sc, Module m)
+    {
+        sc.types[n] = t;
+        auto sym = m.symbol.createMember(n, t);
+        auto id = new Identifier(n);
+        id.env = sc;
+        auto decl = new DummyDecl();
+        decl.sym = sym;
+        decl.env = sc;
+        sc.put(id, decl);
+    }
+
     override void visitModule(Module m)
     {
-        table ~= new Scope;
-        table[table.length-1].types["void"]    = DType.Void;
-        table[table.length-1].types["bool"]    = DType.Bool;
-        table[table.length-1].types["byte"]    = DType.Byte;
-        table[table.length-1].types["ubyte"]   = DType.UByte;
-        table[table.length-1].types["short"]   = DType.Short;
-        table[table.length-1].types["ushort"]  = DType.UShort;
-        table[table.length-1].types["int"]     = DType.Int;
-        table[table.length-1].types["uint"]    = DType.UInt;
-        table[table.length-1].types["long"]    = DType.Long;
-        table[table.length-1].types["ulong"]   = DType.ULong;
-        table[table.length-1].types["char"]    = DType.Char;
-        table[table.length-1].types["wchar"]   = DType.WChar;
-        table[table.length-1].types["dchar"]   = DType.DChar;
+        auto root = new Scope;
+        table ~= root;
+
+        m.symbol = new Symbol;
 
-        table[table.length-1].types["float"]   = DType.Float;
-        table[table.length-1].types["double"]  = DType.Double;
-        table[table.length-1].types["real"]    = DType.Real;
+        registerBasicTypeTo("void",     DType.Void, root, m);
+        registerBasicTypeTo("bool",     DType.Bool, root, m);
+        registerBasicTypeTo("byte",     DType.Byte, root, m);
+        registerBasicTypeTo("ubyte",    DType.UByte, root, m);
+        registerBasicTypeTo("short",    DType.Short, root, m);
+        registerBasicTypeTo("ushort",   DType.UShort, root, m);
+        registerBasicTypeTo("int",      DType.Int, root, m);
+        registerBasicTypeTo("uint",     DType.UInt, root, m);
+        registerBasicTypeTo("long",     DType.Long, root, m);
+        registerBasicTypeTo("ulong",    DType.ULong, root, m);
+
+        registerBasicTypeTo("char",     DType.Char, root, m);
+        registerBasicTypeTo("wchar",    DType.WChar, root, m);
+        registerBasicTypeTo("dchar",    DType.DChar, root, m);
+
+        registerBasicTypeTo("float",    DType.Float, root, m);
+        registerBasicTypeTo("double",   DType.Double, root, m);
+        registerBasicTypeTo("real",     DType.Real, root, m);
 
         current().inModule = m;
         current().mHandle = mHandle;
@@ -145,7 +208,7 @@
 
     override void visitFuncDecl(FuncDecl d)
     {
-        current().add(d.identifier);
+        current().put(d.identifier, d);
         auto sc = push();
 
         visitExp(d.returnType);
@@ -173,7 +236,7 @@
         }
 
         auto sc = current();
-        sc.add(d.identifier);
+        sc.put(d.identifier, d);
         d.env = sc;
         visitExp(d.varType);
         visitExp(d.identifier);
@@ -182,10 +245,10 @@
     override void visitStructDecl(StructDecl s)
     {
         auto sc = current();
-        sc.add(s.identifier);
+        sc.put(s.identifier, s);
         s.env = sc;
         auto type = new DStruct(s.identifier);
-        
+
         sc.types[s.identifier.get] = type;
 
         sc = push();