diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 9a4a5b24b83b4..15c0e4994a567 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -35,22 +35,12 @@ tag def {
     def_ty(def_id);
     def_ty_arg(def_id);
     def_binding(def_id);
+    def_use(def_id);
 }
 
 type crate = spanned[crate_];
 type crate_ = rec(_mod module);
 
-type use_node = spanned[use_node_];
-type use_node_ = rec(ident name, vec[@meta_item] metadata);
-
-type import_node = spanned[import_node_];
-type import_node_ = rec(vec[ident] identifiers);
-
-tag use_or_import {
-    use_or_import_use(@use_node);
-    use_or_import_import(@import_node);
-}
-
 type meta_item = spanned[meta_item_];
 type meta_item_ = rec(ident name, str value);
 
@@ -223,16 +213,25 @@ type _obj = rec(vec[obj_field] fields,
 
 
 tag mod_index_entry {
+    mie_use(uint);
     mie_item(uint);
     mie_tag_variant(uint /* tag item index */, uint /* variant index */);
 }
 
-type _mod = rec(vec[@item] items,
-                hashmap[ident,mod_index_entry] index);
+type mod_index = hashmap[ident,mod_index_entry];
+type _mod = rec(vec[@view_item] view_items,
+                vec[@item] items,
+                mod_index index);
 
 type variant_arg = rec(@ty ty, def_id id);
 type variant = rec(str name, vec[variant_arg] args, def_id id, ann ann);
 
+type view_item = spanned[view_item_];
+tag view_item_ {
+    view_item_use(ident, vec[@meta_item], def_id);
+    view_item_import(vec[ident], def_id);
+}
+
 type item = spanned[item_];
 tag item_ {
     item_const(ident, @ty, @expr, def_id, ann);
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index dd5a6b50d75da..8c3db0e10ba30 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1405,11 +1405,10 @@ impure fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
 }
 
 impure fn parse_mod_items(parser p, token.token term) -> ast._mod {
-    parse_use_and_imports(p);
-
-    let vec[@ast.item] items = vec();
     auto index = new_str_hash[ast.mod_index_entry]();
+    auto view_items = parse_view(p, index);
     let uint u = 0u;
+    let vec[@ast.item] items = vec();
     while (p.peek() != term) {
         auto item = parse_item(p);
         items += vec(item);
@@ -1443,7 +1442,7 @@ impure fn parse_mod_items(parser p, token.token term) -> ast._mod {
 
         u += 1u;
     }
-    ret rec(items=items, index=index);
+    ret rec(view_items=view_items, items=items, index=index);
  }
 
 impure fn parse_item_const(parser p) -> @ast.item {
@@ -1662,17 +1661,18 @@ impure fn parse_optional_meta(parser p) -> vec[@ast.meta_item] {
     }
 }
 
-impure fn parse_use(parser p) -> @ast.use_node {
+impure fn parse_use(parser p) -> @ast.view_item {
     auto lo = p.get_span();
     auto hi = lo;
     expect(p, token.USE);
     auto ident = parse_ident(p);
     auto metadata = parse_optional_meta(p);
     expect(p, token.SEMI);
-    ret @spanned(lo, hi, rec(name = ident, metadata = metadata));
+    auto use_decl = ast.view_item_use(ident, metadata, p.next_def_id());
+    ret @spanned(lo, hi, use_decl);
 }
 
-impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.import_node {
+impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.view_item {
     auto lo = p.get_span();
     auto hi = lo;
     let vec[ast.ident] identifiers = vec();
@@ -1683,10 +1683,11 @@ impure fn parse_rest_import_name(parser p, ast.ident id) -> @ast.import_node {
         identifiers += i;
     }
     p.bump();
-    ret @spanned(lo, hi, rec(identifiers = identifiers));
+    auto import_decl = ast.view_item_import(identifiers, p.next_def_id());
+    ret @spanned(lo, hi, import_decl);
 }
 
-impure fn parse_full_import_name(parser p) -> @ast.import_node {
+impure fn parse_full_import_name(parser p) -> @ast.view_item {
     alt (p.peek()) {
         case (token.IDENT(?ident)) {
             p.bump();
@@ -1699,7 +1700,7 @@ impure fn parse_full_import_name(parser p) -> @ast.import_node {
     fail;
 }
 
-impure fn parse_import(parser p) -> @ast.import_node {
+impure fn parse_import(parser p) -> @ast.view_item {
     expect(p, token.IMPORT);
     alt (p.peek()) {
         case (token.IDENT(?ident)) {
@@ -1721,21 +1722,44 @@ impure fn parse_import(parser p) -> @ast.import_node {
     fail;
 }
 
-impure fn parse_use_and_imports(parser p) -> vec[ast.use_or_import] {
-    let vec[ast.use_or_import] items = vec();
-    while (true) {
-        alt (p.peek()) {
-            case (token.USE) {
-                items += vec(ast.use_or_import_use(parse_use(p)));
-            }
-            case (token.IMPORT) {
-                items += vec(ast.use_or_import_import(parse_import(p)));
+impure fn parse_use_or_import(parser p) -> @ast.view_item {
+    alt (p.peek()) {
+        case (token.USE) {
+            ret parse_use(p);
+        }
+        case (token.IMPORT) {
+            ret parse_import(p);
+        }
+    }
+}
+
+fn is_use_or_import(token.token t) -> bool {
+    if (t == token.USE) {
+        ret true;
+    }
+    if (t == token.IMPORT) {
+        ret true;
+    }
+    ret false;
+}
+
+impure fn parse_view(parser p, ast.mod_index index) -> vec[@ast.view_item] {
+    let vec[@ast.view_item] items = vec();
+    let uint u = 0u;
+    while (is_use_or_import(p.peek())) {
+        auto item = parse_use_or_import(p);
+        items += vec(item);
+        alt (item.node) {
+            case(ast.view_item_use(?id, _, _)) {
+                index.insert(id, ast.mie_use(u));
             }
-            case (_) {
-                ret items;
+            case(ast.view_item_import(?ids,_)) {
+                // FIXME
             }
         }
+        u = u + 1u;
     }
+    ret items;
 }
 
 impure fn parse_crate_from_crate_file(parser p) -> @ast.crate {
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 7f344d95293e1..551993dda8b79 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -67,10 +67,24 @@ fn lookup_name(&env e, ast.ident i) -> option.t[def] {
         ret none[def];
     }
 
+    fn found_def_view(@ast.view_item i) -> option.t[def] {
+        alt (i.node) {
+            case (ast.view_item_use(_, _, ?id)) {
+                ret some[def](ast.def_use(id));
+            }
+            case (ast.view_item_import(_,?id)) {
+                fail;
+            }
+        }
+    }
+
     fn check_mod(ast.ident i, ast._mod m) -> option.t[def] {
         alt (m.index.find(i)) {
             case (some[ast.mod_index_entry](?ent)) {
                 alt (ent) {
+                    case (ast.mie_use(?ix)) {
+                        ret found_def_view(m.view_items.(ix));
+                    }
                     case (ast.mie_item(?ix)) {
                         ret found_def_item(m.items.(ix));
                     }