diff --git a/bench/binarytrees/binarytrees-mt.dora b/bench/binarytrees/binarytrees-mt.dora
index e01645bf5..b6651c6bf 100644
--- a/bench/binarytrees/binarytrees-mt.dora
+++ b/bench/binarytrees/binarytrees-mt.dora
@@ -1,6 +1,7 @@
 const MIN_DEPTH: Int32 = 4i32;
 const DEFAULT_DEPTH: Int32 = 6i32;
 const DEFAULT_THREADS: Int32 = 4i32;
+use std::string::Stringable;
 
 fn main() {
     let maxDepth = if std::argc() > 0i32 {
diff --git a/bench/binarytrees/binarytrees.dora b/bench/binarytrees/binarytrees.dora
index 8faa5936c..db9a3ac00 100644
--- a/bench/binarytrees/binarytrees.dora
+++ b/bench/binarytrees/binarytrees.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
   let mut maxDepth = 6i32;
 
diff --git a/bench/fannkuchredux/fannkuchredux.dora b/bench/fannkuchredux/fannkuchredux.dora
index 0ecfef4b5..af4956530 100644
--- a/bench/fannkuchredux/fannkuchredux.dora
+++ b/bench/fannkuchredux/fannkuchredux.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
   let mut n = 7i32;
   if std::argc() > 0i32 { n = std::argv(0i32).toInt32().getOrPanic(); }
diff --git a/bench/gcbench/gcbench.dora b/bench/gcbench/gcbench.dora
index 3ddfa21a8..b4e485f2f 100644
--- a/bench/gcbench/gcbench.dora
+++ b/bench/gcbench/gcbench.dora
@@ -1,6 +1,7 @@
 use std::argc;
 use std::argv;
 use std::timestamp;
+use std::string::Stringable;
 
 class Node {
     left: Option[Node],
diff --git a/bench/gcold/gcold.dora b/bench/gcold/gcold.dora
index 54a729477..aa5910864 100644
--- a/bench/gcold/gcold.dora
+++ b/bench/gcold/gcold.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 class TreeNode {
     left: Option[TreeNode],
     right: Option[TreeNode],
diff --git a/bench/nbody/nbody.dora b/bench/nbody/nbody.dora
index 0bc2a4929..436886c12 100644
--- a/bench/nbody/nbody.dora
+++ b/bench/nbody/nbody.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
     SOLAR_MASS = 4.0 * PI * PI;
     let n = std::argv(0i32).toInt32().getOrPanic();
diff --git a/bench/richards/richards.dora b/bench/richards/richards.dora
index 76549451c..7accfdde7 100644
--- a/bench/richards/richards.dora
+++ b/bench/richards/richards.dora
@@ -1,6 +1,7 @@
 // Dora implementation of Richards benchmark. 
 // Originally implemented in BCPL (http://www.cl.cam.ac.uk/~mr10/Bench.html)
 // Used in Octane 2.0 (https://developers.google.com/octane/benchmark)
+use std::traits::{IndexGet, IndexSet, Not};
 
 fn main() {
     let mut iterations = 8200i32;
diff --git a/bench/splay/splay.dora b/bench/splay/splay.dora
index ef9e87419..1e17ef95e 100644
--- a/bench/splay/splay.dora
+++ b/bench/splay/splay.dora
@@ -1,5 +1,6 @@
 use std::fatalError;
 use std::timestamp;
+use std::string::Stringable;
 
 fn main() {
     if std::argc() != 3i32 {
diff --git a/bench/splunc/splunc.dora b/bench/splunc/splunc.dora
index 58180886c..169b66d52 100644
--- a/bench/splunc/splunc.dora
+++ b/bench/splunc/splunc.dora
@@ -1,6 +1,7 @@
 use std::argc;
 use std::argv;
 use std::exit;
+use std::string::Stringable;
 
 class Node {
     payload: Option[Array[Int32]],
diff --git a/dora-frontend/src/generator/tests.rs b/dora-frontend/src/generator/tests.rs
index b71439605..3a88a8634 100644
--- a/dora-frontend/src/generator/tests.rs
+++ b/dora-frontend/src/generator/tests.rs
@@ -25,6 +25,9 @@ fn sema(code: &'static str) -> Sema {
     let mut sa = Sema::new(args);
 
     let result = check_program(&mut sa);
+    if sa.diag.borrow().has_errors() {
+        sa.diag.borrow_mut().dump(&sa, true);
+    }
     assert!(!sa.diag.borrow().has_errors());
     assert!(result);
 
@@ -3750,7 +3753,10 @@ fn gen_array_get() {
 
 #[test]
 fn gen_array_get_method() {
-    let sa = sema("fn f(x: Array[Float32], idx: Int64): Float32 { x.get(idx) }");
+    let sa = sema(
+        "use std::traits::IndexGet;
+        fn f(x: Array[Float32], idx: Int64): Float32 { x.get(idx) }",
+    );
     let (_, code) = bc(&sa, "<prog>::f");
     let expected = vec![LoadArray(r(2), r(0), r(1)), Ret(r(2))];
     assert_eq!(expected, code);
@@ -3758,7 +3764,11 @@ fn gen_array_get_method() {
 
 #[test]
 fn gen_array_set_method() {
-    let sa = sema("fn f(x: Array[Float32], idx: Int64, value: Float32) { x.set(idx, value); }");
+    let sa = sema(
+        "
+        use std::traits::IndexSet;
+        fn f(x: Array[Float32], idx: Int64, value: Float32) { x.set(idx, value); }",
+    );
     let (_, code) = bc(&sa, "<prog>::f");
     let expected = vec![StoreArray(r(2), r(0), r(1)), Ret(r(3))];
     assert_eq!(expected, code);
@@ -3811,7 +3821,12 @@ fn gen_string_equals() {
 
 #[test]
 fn gen_bool_to_string() {
-    let sa = sema("fn f(a: Bool): String { a.toString() }");
+    let sa = sema(
+        "
+        use std::string::Stringable;
+        fn f(a: Bool): String { a.toString() }
+    ",
+    );
     let (fct, code) = bc(&sa, "<prog>::f");
 
     let fct_id = lookup_fct(
diff --git a/dora-frontend/src/impldefck.rs b/dora-frontend/src/impldefck.rs
index 860532be3..0bb41d809 100644
--- a/dora-frontend/src/impldefck.rs
+++ b/dora-frontend/src/impldefck.rs
@@ -1160,9 +1160,9 @@ mod tests {
     #[test]
     fn impl_generic_extended_ty() {
         ok("
-            trait Foo[T] { fn getter(): T; }
+            trait Foo[T] { fn get(): T; }
             impl[T] Foo[T] for T {
-                fn getter(): T { self }
+                fn get(): T { self }
             }
             fn f(x: Int64): Foo[Int64] { x as Foo[Int64] }
         ");
diff --git a/dora-frontend/src/sym.rs b/dora-frontend/src/sym.rs
index 4ebed4e75..5acb97236 100644
--- a/dora-frontend/src/sym.rs
+++ b/dora-frontend/src/sym.rs
@@ -1,6 +1,6 @@
 use parking_lot::RwLock;
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -81,6 +81,24 @@ impl ModuleSymTable {
         None
     }
 
+    pub fn contains_trait(&self, trait_id: TraitDefinitionId) -> bool {
+        for level in self.levels.iter().rev() {
+            if level.contains_trait(trait_id) {
+                return true;
+            }
+        }
+
+        if self.outer.contains_trait(trait_id) {
+            return true;
+        }
+
+        if self.prelude.contains_trait(trait_id) {
+            return true;
+        }
+
+        false
+    }
+
     pub fn insert(&mut self, name: Name, sym: SymbolKind) -> Option<Symbol> {
         self.levels.last_mut().unwrap().insert(name, sym)
     }
@@ -89,6 +107,7 @@ impl ModuleSymTable {
 #[derive(Debug)]
 pub struct SymTable {
     table: HashMap<Name, Symbol>,
+    traits: HashSet<TraitDefinitionId>,
 }
 
 impl SymTable {
@@ -96,6 +115,7 @@ impl SymTable {
     pub fn new() -> SymTable {
         SymTable {
             table: HashMap::new(),
+            traits: HashSet::new(),
         }
     }
 
@@ -107,6 +127,10 @@ impl SymTable {
         self.table.get(&name)
     }
 
+    pub fn contains_trait(&self, trait_id: TraitDefinitionId) -> bool {
+        self.traits.contains(&trait_id)
+    }
+
     pub fn insert(&mut self, name: Name, kind: SymbolKind) -> Option<Symbol> {
         let symbol = Symbol {
             visibility: None,
@@ -125,6 +149,9 @@ impl SymTable {
             visibility: Some(visibility),
             kind,
         };
+        if let SymbolKind::Trait(trait_id) = kind {
+            self.traits.insert(trait_id);
+        }
         self.table.insert(name, symbol)
     }
 
@@ -151,7 +178,7 @@ impl Symbol {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum SymbolKind {
     Class(ClassDefinitionId),
     Struct(StructDefinitionId),
diff --git a/dora-frontend/src/typeck/call.rs b/dora-frontend/src/typeck/call.rs
index bc17ad22f..8d09a5576 100644
--- a/dora-frontend/src/typeck/call.rs
+++ b/dora-frontend/src/typeck/call.rs
@@ -302,6 +302,7 @@ fn check_expr_call_static_method(
 
     let candidates = find_method_call_candidates(
         ck.sa,
+        &ck.symtable,
         object_type.clone(),
         &ck.type_param_definition,
         interned_method_name,
@@ -387,6 +388,7 @@ fn check_expr_call_method(
 
     let candidates = find_method_call_candidates(
         ck.sa,
+        &ck.symtable,
         object_type.clone(),
         &ck.type_param_definition,
         interned_method_name,
@@ -599,7 +601,7 @@ fn check_expr_call_ctor_with_named_fields(
                 let def_ty = replace_type(ck.sa, field.ty, Some(&type_params), None);
                 let arg_ty = ck.analysis.ty(arg.id);
 
-                if !def_ty.allows(ck.sa, arg_ty.clone()) {
+                if !def_ty.allows(ck.sa, arg_ty.clone()) && !arg_ty.is_error() {
                     let exp = ck.ty_name(&def_ty);
                     let got = ck.ty_name(&arg_ty);
 
@@ -643,7 +645,7 @@ fn check_expr_call_ctor_with_unnamed_fields(
                 .report(ck.file_id, name.span, ErrorMessage::UnexpectedNamedArgument);
         }
 
-        if !def_ty.allows(ck.sa, arg_ty.clone()) {
+        if !def_ty.allows(ck.sa, arg_ty.clone()) && !arg_ty.is_error() {
             let exp = ck.ty_name(&def_ty);
             let got = ck.ty_name(&arg_ty);
 
diff --git a/dora-frontend/src/typeck/expr.rs b/dora-frontend/src/typeck/expr.rs
index 46a722900..999c4ff71 100644
--- a/dora-frontend/src/typeck/expr.rs
+++ b/dora-frontend/src/typeck/expr.rs
@@ -329,7 +329,8 @@ fn check_expr_assign_call(ck: &mut TypeCheck, e: &ast::ExprBinType) {
             impl_item_type_alias_ty.clone(),
             value_type.clone(),
             None,
-        ) {
+        ) && !value_type.is_error()
+        {
             let exp = ck.ty_name(&impl_item_type_alias_ty);
             let got = ck.ty_name(&value_type);
             ck.sa.report(
diff --git a/dora-frontend/src/typeck/function.rs b/dora-frontend/src/typeck/function.rs
index 34145357b..bbc166e22 100644
--- a/dora-frontend/src/typeck/function.rs
+++ b/dora-frontend/src/typeck/function.rs
@@ -466,7 +466,9 @@ pub(super) fn check_args_compatible(
         );
         let arg_ty = ck.analysis.ty(arg.id);
 
-        if !arg_allows(ck.sa, param_ty.clone(), arg_ty.clone(), self_ty.clone()) {
+        if !arg_allows(ck.sa, param_ty.clone(), arg_ty.clone(), self_ty.clone())
+            && !arg_ty.is_error()
+        {
             let exp = ck.ty_name(&param_ty);
             let got = ck.ty_name(&arg_ty);
 
@@ -498,7 +500,9 @@ pub(super) fn check_args_compatible(
             for arg in &args.arguments[no_regular_params..] {
                 let arg_ty = ck.analysis.ty(arg.id);
 
-                if !arg_allows(ck.sa, variadic_ty.clone(), arg_ty.clone(), self_ty.clone()) {
+                if !arg_allows(ck.sa, variadic_ty.clone(), arg_ty.clone(), self_ty.clone())
+                    && !arg_ty.is_error()
+                {
                     let exp = ck.ty_name(&variadic_ty);
                     let got = ck.ty_name(&arg_ty);
 
diff --git a/dora-frontend/src/typeck/lookup.rs b/dora-frontend/src/typeck/lookup.rs
index ba84171b7..38c4c7432 100644
--- a/dora-frontend/src/typeck/lookup.rs
+++ b/dora-frontend/src/typeck/lookup.rs
@@ -2,16 +2,19 @@ use crate::interner::Name;
 use crate::sema::{
     extension_matches, impl_matches, Candidate, Sema, TraitDefinition, TypeParamDefinition,
 };
-use crate::SourceType;
+use crate::sym::ModuleSymTable;
+use crate::{package_for_type, SourceType};
 
 pub fn find_method_call_candidates(
     sa: &Sema,
+    table: &ModuleSymTable,
     object_type: SourceType,
     type_param_defs: &TypeParamDefinition,
     name: Name,
     is_static: bool,
 ) -> Vec<Candidate> {
     let mut candidates = Vec::with_capacity(1);
+    let package_id = sa.module(table.module_id()).package_id();
 
     if let SourceType::TraitObject(trait_id, trait_type_params, _bindings) = object_type.clone() {
         let trait_ = sa.trait_(trait_id);
@@ -55,10 +58,20 @@ pub fn find_method_call_candidates(
     }
 
     for (_id, impl_) in sa.impls.iter() {
-        if let Some(bindings) = impl_matches(sa, object_type.clone(), type_param_defs, impl_.id()) {
-            if let Some(trait_ty) = impl_.trait_ty() {
-                let trait_ = &sa.trait_(trait_ty.trait_id);
+        if let Some(trait_ty) = impl_.trait_ty() {
+            let trait_ = &sa.trait_(trait_ty.trait_id);
 
+            let is_trait_foreign = trait_.package_id != package_id;
+            let is_extended_ty_foreign =
+                package_for_type(sa, impl_.extended_ty()) != Some(package_id);
+
+            if is_trait_foreign && !table.contains_trait(trait_.id()) && is_extended_ty_foreign {
+                continue;
+            }
+
+            if let Some(bindings) =
+                impl_matches(sa, object_type.clone(), type_param_defs, impl_.id())
+            {
                 if let Some(trait_method_id) = trait_.get_method(name, is_static) {
                     if let Some(fct_id) = impl_.get_method_for_trait_method_id(trait_method_id) {
                         candidates.push(Candidate {
diff --git a/dora-frontend/src/typeck/tests.rs b/dora-frontend/src/typeck/tests.rs
index 2392b1bbc..63e8dcb2c 100644
--- a/dora-frontend/src/typeck/tests.rs
+++ b/dora-frontend/src/typeck/tests.rs
@@ -2585,7 +2585,9 @@ fn for_with_array() {
 
 #[test]
 fn for_with_vec() {
-    ok("fn f(x: Vec[Int32]): Int32 {
+    ok("
+    use std::traits::IntoIterator;
+    fn f(x: Vec[Int32]): Int32 {
         let mut result = 0i32;
         for i in x.iter() {
             result = result + i;
@@ -3972,6 +3974,7 @@ fn alias_in_local_type() {
 #[test]
 fn for_iterator_trait() {
     ok("
+        use std::traits::IntoIterator;
         fn f() {
             let it = Array[Int64]::new(1, 2, 3).iter();
             let mut sum = 0;
diff --git a/pkgs/boots/assembler.dora b/pkgs/boots/assembler.dora
index ca8b98164..4a7edc65d 100644
--- a/pkgs/boots/assembler.dora
+++ b/pkgs/boots/assembler.dora
@@ -1,6 +1,6 @@
 use std::Hash;
 use std::Equals;
-use std::traits::Iterator;
+use std::traits::{IntoIterator, Iterator};
 
 use package::graph::Location;
 
diff --git a/pkgs/boots/graph.dora b/pkgs/boots/graph.dora
index 24848d554..ef045a941 100644
--- a/pkgs/boots/graph.dora
+++ b/pkgs/boots/graph.dora
@@ -3,7 +3,7 @@ use std::collections::{BitVecIter, HashMap};
 use std::Equals;
 use std::Hash;
 use std::Stringable;
-use std::traits::Iterator;
+use std::traits::{IndexGet, IntoIterator, Iterator};
 
 use package::assembler::{FloatRegister, Label, Register, RegMap, RegSet};
 use package::bytecode::{BytecodeType, ClassId, FunctionId, ClassFieldId, GlobalId, StructId, TraitId};
diff --git a/pkgs/boots/interface.dora b/pkgs/boots/interface.dora
index df81e0652..2b6fb29cc 100644
--- a/pkgs/boots/interface.dora
+++ b/pkgs/boots/interface.dora
@@ -1,4 +1,5 @@
 use std::collections::VecIter;
+use std::traits::IntoIterator;
 
 use package::bytecode::{BytecodeFunction, BytecodeType, ConstPoolId, FunctionId, Location};
 use package::bytecode::{ClassId, EnumId, ClassFieldId, GlobalId, StructId, StructFieldId, TraitId};
diff --git a/pkgs/boots/resolver.dora b/pkgs/boots/resolver.dora
index f6ecfb63e..32e5f6d99 100644
--- a/pkgs/boots/resolver.dora
+++ b/pkgs/boots/resolver.dora
@@ -1,4 +1,5 @@
 use std::collections::{HashMap, HashSet};
+use std::traits::{IntoIterator, Iterator};
 
 use package::assembler::{FloatRegister, Register, RegisterType};
 use package::codegen::CodeGen;
diff --git a/tests/array/array-compare.dora b/tests/array/array-compare.dora
index d9341033c..15b8999b5 100644
--- a/tests/array/array-compare.dora
+++ b/tests/array/array-compare.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
   let a = Array[Int32]::new(1i32, 2i32, 3i32, 3i32, 4i32, 5i32, 4i32, 5i32, 4i32, 3i32, 3i32);
   let b = Array[Int32]::new(1i32, 2i32, 3i32, 3i32, 4i32, 5i32, 4i32, 5i32, 4i32, 3i32, 4i32);
diff --git a/tests/array/array-enumerate2.dora b/tests/array/array-enumerate2.dora
index 3df4073ae..a9680fd49 100644
--- a/tests/array/array-enumerate2.dora
+++ b/tests/array/array-enumerate2.dora
@@ -1,3 +1,5 @@
+use std::traits::Iterator;
+
 fn main() {
     iterateManually();
     iterateWithForIn();
diff --git a/tests/array/array-equals.dora b/tests/array/array-equals.dora
index 2677426de..3720f3943 100644
--- a/tests/array/array-equals.dora
+++ b/tests/array/array-equals.dora
@@ -1,3 +1,5 @@
+use std::traits::Equals;
+
 fn main() {
   assert(Array[Int32]::new() == Array[Int32]::new());
   assert(Array[Int32]::new().equals(Array[Int32]::new()));
diff --git a/tests/array/array-toString.dora b/tests/array/array-toString.dora
index 674ac17bd..e8cb38d42 100644
--- a/tests/array/array-toString.dora
+++ b/tests/array/array-toString.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
   assert(Array[Int32]::new().toString() == "Array()");
   assert(Array[Int32]::new(1i32).toString() == "Array(1)");
diff --git a/tests/boots/compare-ordering-float32.dora b/tests/boots/compare-ordering-float32.dora
index d3eb81442..23cc669d4 100644
--- a/tests/boots/compare-ordering-float32.dora
+++ b/tests/boots/compare-ordering-float32.dora
@@ -1,6 +1,7 @@
 //= boots
 
 use std::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(f(1.0f32, 2.0f32) == Ordering::Less);
diff --git a/tests/boots/compare-ordering-float64.dora b/tests/boots/compare-ordering-float64.dora
index a6ce1a695..9e164e31d 100644
--- a/tests/boots/compare-ordering-float64.dora
+++ b/tests/boots/compare-ordering-float64.dora
@@ -1,6 +1,7 @@
 //= boots
 
 use std::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(f(1.0, 2.0) == Ordering::Less);
diff --git a/tests/boots/compare-ordering-int32.dora b/tests/boots/compare-ordering-int32.dora
index 0bf63aa58..0f1aca8bb 100644
--- a/tests/boots/compare-ordering-int32.dora
+++ b/tests/boots/compare-ordering-int32.dora
@@ -1,6 +1,7 @@
 //= boots
 
 use std::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(f(1i32, 2i32) == Ordering::Less);
diff --git a/tests/boots/compare-ordering-int64.dora b/tests/boots/compare-ordering-int64.dora
index ea67d8bf4..53321abaf 100644
--- a/tests/boots/compare-ordering-int64.dora
+++ b/tests/boots/compare-ordering-int64.dora
@@ -1,6 +1,7 @@
 //= boots
 
 use std::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(f(1, 2) == Ordering::Less);
diff --git a/tests/boots/compare-ordering-uint8.dora b/tests/boots/compare-ordering-uint8.dora
index 8573b14ba..e7ca5f9be 100644
--- a/tests/boots/compare-ordering-uint8.dora
+++ b/tests/boots/compare-ordering-uint8.dora
@@ -1,6 +1,7 @@
 //= boots
 
 use std::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(f(1u8, 2u8) == Ordering::Less);
diff --git a/tests/float/float0.dora b/tests/float/float0.dora
index 941f2dde0..c6a794878 100644
--- a/tests/float/float0.dora
+++ b/tests/float/float0.dora
@@ -1,3 +1,5 @@
+use std::traits::{Add, Div, Mod, Mul, Neg, Not, Sub};
+
 fn main() {
   let x = 1.0f32.neg();
   assert(x == -1.0f32);
diff --git a/tests/float/float64_0.dora b/tests/float/float64_0.dora
index c4e577aa3..f31f67050 100644
--- a/tests/float/float64_0.dora
+++ b/tests/float/float64_0.dora
@@ -1,3 +1,5 @@
+use std::traits::{Add, Div, Mod, Mul, Neg, Not, Sub};
+
 fn main() {
   let x = 1.0.neg();
   assert(x == -1.0);
diff --git a/tests/float/float9.dora b/tests/float/float9.dora
index cb8315f7b..8409e9e44 100644
--- a/tests/float/float9.dora
+++ b/tests/float/float9.dora
@@ -1,4 +1,5 @@
 //= stdout "1\n1\n"
+use std::string::Stringable;
 
 fn main() {
     let x = 1f32;
diff --git a/tests/for/for-range1.dora b/tests/for/for-range1.dora
index e90f00761..72711cd28 100644
--- a/tests/for/for-range1.dora
+++ b/tests/for/for-range1.dora
@@ -1,4 +1,5 @@
 //= stdout "01234"
+use std::string::Stringable;
 
 fn main() {
     for i in std::range(0, 5) {
diff --git a/tests/for/for-range2.dora b/tests/for/for-range2.dora
index 049e16bee..5a51b4da4 100644
--- a/tests/for/for-range2.dora
+++ b/tests/for/for-range2.dora
@@ -1,4 +1,5 @@
 //= stdout "012"
+use std::string::Stringable;
 
 fn main() {
     for i in std::range(0, 5) {
diff --git a/tests/for/for-range3.dora b/tests/for/for-range3.dora
index 69194e534..2d378b98e 100644
--- a/tests/for/for-range3.dora
+++ b/tests/for/for-range3.dora
@@ -1,4 +1,5 @@
 //= stdout "0124"
+use std::string::Stringable;
 
 fn main() {
     for i in std::range(0, 5) {
diff --git a/tests/gc/gc10.dora b/tests/gc/gc10.dora
index d358fa5ee..b59e97a9b 100644
--- a/tests/gc/gc10.dora
+++ b/tests/gc/gc10.dora
@@ -1,4 +1,5 @@
 //= stdout "10\n10\n"
+use std::string::Stringable;
 
 fn main() {
     let a = A(10i32);
diff --git a/tests/generic/generic-ge1.dora b/tests/generic/generic-ge1.dora
index 2fe2ba27e..10107000f 100644
--- a/tests/generic/generic-ge1.dora
+++ b/tests/generic/generic-ge1.dora
@@ -1,3 +1,5 @@
+use std::traits::Comparable;
+
 fn main() {
     assert(ge[Int64](10, 10));
     assert(ge[Int64](12, 10));
diff --git a/tests/generic/generic-gt1.dora b/tests/generic/generic-gt1.dora
index 1e913efa0..e21b6c96c 100644
--- a/tests/generic/generic-gt1.dora
+++ b/tests/generic/generic-gt1.dora
@@ -1,3 +1,5 @@
+use std::traits::Comparable;
+
 fn main() {
     assert(!gt[Int64](10, 10));
     assert(gt[Int64](12, 10));
diff --git a/tests/generic/generic-le1.dora b/tests/generic/generic-le1.dora
index be7d26f11..22330bbd0 100644
--- a/tests/generic/generic-le1.dora
+++ b/tests/generic/generic-le1.dora
@@ -1,3 +1,5 @@
+use std::traits::Comparable;
+
 fn main() {
     assert(le[Int64](10, 10));
     assert(le[Int64](10, 12));
diff --git a/tests/generic/generic-lt1.dora b/tests/generic/generic-lt1.dora
index 69a8e634c..dea7a5066 100644
--- a/tests/generic/generic-lt1.dora
+++ b/tests/generic/generic-lt1.dora
@@ -1,3 +1,5 @@
+use std::traits::Comparable;
+
 fn main() {
     assert(!lt[Int64](10, 10));
     assert(lt[Int64](10, 12));
diff --git a/tests/generic/generic1.dora b/tests/generic/generic1.dora
index 205a930a6..c823e174b 100644
--- a/tests/generic/generic1.dora
+++ b/tests/generic/generic1.dora
@@ -1,4 +1,5 @@
 //= stdout "1"
+use std::string::Stringable;
 
 fn main() {
     let a = A[Int32](1i32);
diff --git a/tests/generic/generic2.dora b/tests/generic/generic2.dora
index 32731bd6e..99f4f2c30 100644
--- a/tests/generic/generic2.dora
+++ b/tests/generic/generic2.dora
@@ -1,4 +1,5 @@
 //= stdout "hello1"
+use std::string::Stringable;
 
 fn main() {
   let a = A[String](foo(1i32));
diff --git a/tests/generic/generic4.dora b/tests/generic/generic4.dora
index 73468d5ec..8308d1d3b 100644
--- a/tests/generic/generic4.dora
+++ b/tests/generic/generic4.dora
@@ -1,4 +1,5 @@
 //= stdout "hello1"
+use std::string::Stringable;
 
 fn main() {
   let a = A[String](foo(1i32));
diff --git a/tests/impl/impl2.dora b/tests/impl/impl2.dora
index ae9e9f41a..2f347b65c 100644
--- a/tests/impl/impl2.dora
+++ b/tests/impl/impl2.dora
@@ -1,5 +1,7 @@
 //= stdout "1\n"
 
+use std::string::Stringable;
+
 trait Foo {
     fn bla();
 }
@@ -15,4 +17,4 @@ impl Foo for A {
 fn main() {
     let a = A(1i32);
     a.bla();
-}
\ No newline at end of file
+}
diff --git a/tests/int/expr2.dora b/tests/int/expr2.dora
index 494a54e5a..e698acccc 100644
--- a/tests/int/expr2.dora
+++ b/tests/int/expr2.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
   let val = 101i32.toString();
   assert(val == "101");
diff --git a/tests/int/int-shift-rotate.dora b/tests/int/int-shift-rotate.dora
index f86555ae2..0408dc23f 100644
--- a/tests/int/int-shift-rotate.dora
+++ b/tests/int/int-shift-rotate.dora
@@ -1,3 +1,5 @@
+use std::traits::{Sar, Shl, Shr};
+
 fn main() {
     let x = 1i32.shl(1i32);
     assert(x == 2i32);
diff --git a/tests/int/int1.dora b/tests/int/int1.dora
index a028fa5f9..08c20906f 100644
--- a/tests/int/int1.dora
+++ b/tests/int/int1.dora
@@ -1,3 +1,5 @@
+use std::traits::{Add, BitAnd, BitOr, BitXor, Div, Mod, Mul, Neg, Not, Sub};
+
 fn main() {
     let x = 1i32.neg();
     assert(x == -1i32);
diff --git a/tests/int/int64-2.dora b/tests/int/int64-2.dora
index aa484d2a6..03252b6a9 100644
--- a/tests/int/int64-2.dora
+++ b/tests/int/int64-2.dora
@@ -1,3 +1,5 @@
+use std::traits::Add;
+
 fn main() {
     let x: Int64 = 1i64;
     let y = 2i64;
diff --git a/tests/int/int64-3.dora b/tests/int/int64-3.dora
index 61d22efcc..1d7d180bc 100644
--- a/tests/int/int64-3.dora
+++ b/tests/int/int64-3.dora
@@ -1,3 +1,5 @@
+use std::traits::{Add, BitAnd, BitOr, BitXor, Div, Mod, Mul, Neg, Not, Sub};
+
 fn main() {
     let x = 1i64.neg();
     assert(x == -1i64);
diff --git a/tests/int/int64-shift-rotate.dora b/tests/int/int64-shift-rotate.dora
index f80f1d497..d113273ca 100644
--- a/tests/int/int64-shift-rotate.dora
+++ b/tests/int/int64-shift-rotate.dora
@@ -1,3 +1,5 @@
+use std::traits::{Sar, Shl, Shr};
+
 fn main() {
     let x = 1i64.shl(1i32);
     assert(x == 2i64);
diff --git a/tests/io/file-create1.dora b/tests/io/file-create1.dora
index 9a6409fb8..84300f413 100644
--- a/tests/io/file-create1.dora
+++ b/tests/io/file-create1.dora
@@ -1,3 +1,5 @@
+use std::io::Write;
+
 fn main() {
     let file = std::io::File::create("tests/io/test123.txt");
     let bytes = "hello\n".asBytes();
diff --git a/tests/io/file-read1.dora b/tests/io/file-read1.dora
index d6c23d4c1..bf96fc759 100644
--- a/tests/io/file-read1.dora
+++ b/tests/io/file-read1.dora
@@ -1,3 +1,5 @@
+use std::io::Read;
+
 fn main() {
     let file = std::io::File::open("tests/io/abc.txt");
     let buffer = Array[UInt8]::zero(4);
diff --git a/tests/io/stderr1.dora b/tests/io/stderr1.dora
index 26cf4693f..dcc5d0b36 100644
--- a/tests/io/stderr1.dora
+++ b/tests/io/stderr1.dora
@@ -1,4 +1,5 @@
 //= stderr "Hello, world!\n"
+use std::io::Write;
 
 fn main() {
   let bytes = "Hello, world!\n".asBytes();
diff --git a/tests/io/stdout1.dora b/tests/io/stdout1.dora
index e231c03cd..f5777a97c 100644
--- a/tests/io/stdout1.dora
+++ b/tests/io/stdout1.dora
@@ -1,4 +1,5 @@
 //= stdout "Hello, world!\n"
+use std::io::Write;
 
 fn main() {
   let bytes = "Hello, world!\n".asBytes();
diff --git a/tests/language/bool1.dora b/tests/language/bool1.dora
index 340c91d8d..3a047ba20 100644
--- a/tests/language/bool1.dora
+++ b/tests/language/bool1.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
   assert(true.toInt32() == 1i32);
   assert(false.toInt32() == 0i32);
diff --git a/tests/language/char1.dora b/tests/language/char1.dora
index 4513fb464..f4501ea23 100644
--- a/tests/language/char1.dora
+++ b/tests/language/char1.dora
@@ -1,4 +1,5 @@
 //= stdout "a\n"
+use std::string::Stringable;
 
 fn main() {
     let ch = 'a';
@@ -13,4 +14,4 @@ fn main() {
 
     assert(ch.toInt32() == 97i32);
     assert(ch.toInt64() == 97i64);
-}
\ No newline at end of file
+}
diff --git a/tests/language/char2.dora b/tests/language/char2.dora
index 6b6700fc3..1f7f56ba3 100644
--- a/tests/language/char2.dora
+++ b/tests/language/char2.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
     let x = Array[Char]::new();
     assert(x.size() == 0i64);
diff --git a/tests/language/global1.dora b/tests/language/global1.dora
index 541737b4c..306c9f487 100644
--- a/tests/language/global1.dora
+++ b/tests/language/global1.dora
@@ -1,4 +1,5 @@
 //= stdout "x = 0\ny = 0\nz = 0\n"
+use std::string::Stringable;
 
 let mut x: Int32 = 0i32;
 let mut y: Int32 = 0i32;
diff --git a/tests/language/global2.dora b/tests/language/global2.dora
index 2e2c37a9c..ec98473aa 100644
--- a/tests/language/global2.dora
+++ b/tests/language/global2.dora
@@ -1,5 +1,7 @@
 //= stdout "x = 1\ny = 2\nz = 3\n"
 
+use std::string::Stringable;
+
 let mut x: Int32 = 0i32;
 let mut y: Int32 = 0i32;
 let mut z: Int32 = 0i32;
diff --git a/tests/language/if1.dora b/tests/language/if1.dora
index d4fc4cafe..d00ac5ec0 100644
--- a/tests/language/if1.dora
+++ b/tests/language/if1.dora
@@ -1,5 +1,7 @@
 //= vm-args "--gc=copy"
 
+use std::string::Stringable;
+
 fn main() {
     assert(f(true) == 1i32);
     assert(f(false) == 2i32);
diff --git a/tests/language/self1.dora b/tests/language/self1.dora
index 191a57d29..e8b26d5bb 100644
--- a/tests/language/self1.dora
+++ b/tests/language/self1.dora
@@ -1,3 +1,5 @@
+use std::traits::Equals;
+
 fn main() {
   assert(0.0 == 0.0);
   assert(0.0.equals(0.0));
diff --git a/tests/stdlib/arg1.dora b/tests/stdlib/arg1.dora
index f1094b0a9..2c0197fbe 100644
--- a/tests/stdlib/arg1.dora
+++ b/tests/stdlib/arg1.dora
@@ -1,4 +1,5 @@
 //= args 1 2 3
+use std::string::Stringable;
 
 fn main() {
   let val = std::argc().toString();
diff --git a/tests/stdlib/bitvec-intersect1.dora b/tests/stdlib/bitvec-intersect1.dora
index 4106414ae..8cf888e4f 100644
--- a/tests/stdlib/bitvec-intersect1.dora
+++ b/tests/stdlib/bitvec-intersect1.dora
@@ -1,3 +1,5 @@
+use std::traits::{IntoIterator, Iterator};
+
 fn main() {
     let s1 = std::BitVec::new();
     s1.insert(0);
diff --git a/tests/stdlib/bitvec-intersect2.dora b/tests/stdlib/bitvec-intersect2.dora
index 25df51db8..3ade81db4 100644
--- a/tests/stdlib/bitvec-intersect2.dora
+++ b/tests/stdlib/bitvec-intersect2.dora
@@ -1,3 +1,5 @@
+use std::traits::{IntoIterator, Iterator};
+
 fn main() {
     let s1 = std::BitVec::new();
     s1.insert(0);
diff --git a/tests/stdlib/bitvec-union1.dora b/tests/stdlib/bitvec-union1.dora
index de41ad866..93e55ba61 100644
--- a/tests/stdlib/bitvec-union1.dora
+++ b/tests/stdlib/bitvec-union1.dora
@@ -1,3 +1,5 @@
+use std::traits::{IntoIterator, Iterator};
+
 fn main() {
     let s1 = std::BitVec::new();
     s1.insert(0);
diff --git a/tests/stdlib/bitvec1.dora b/tests/stdlib/bitvec1.dora
index 38687f62b..23fdcb63d 100644
--- a/tests/stdlib/bitvec1.dora
+++ b/tests/stdlib/bitvec1.dora
@@ -1,3 +1,5 @@
+use std::traits::{IntoIterator, Iterator};
+
 fn main() {
     let set = std::BitVec::new();
     set.insert(0);
diff --git a/tests/stdlib/cmp-char.dora b/tests/stdlib/cmp-char.dora
index 80432370b..cd5d761e1 100644
--- a/tests/stdlib/cmp-char.dora
+++ b/tests/stdlib/cmp-char.dora
@@ -1,4 +1,5 @@
 use std::traits::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert('a'.cmp('b') == Ordering::Less);
diff --git a/tests/stdlib/cmp-float32.dora b/tests/stdlib/cmp-float32.dora
index fe8e36d8d..1ce9ae960 100644
--- a/tests/stdlib/cmp-float32.dora
+++ b/tests/stdlib/cmp-float32.dora
@@ -1,4 +1,5 @@
 use std::traits::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(0.0f32.cmp(1.0f32) == Ordering::Less);
diff --git a/tests/stdlib/cmp-float64.dora b/tests/stdlib/cmp-float64.dora
index 874ff58c4..fe5d1027f 100644
--- a/tests/stdlib/cmp-float64.dora
+++ b/tests/stdlib/cmp-float64.dora
@@ -1,4 +1,5 @@
 use std::traits::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(0.0f64.cmp(1.0f64) == Ordering::Less);
diff --git a/tests/stdlib/cmp-int32.dora b/tests/stdlib/cmp-int32.dora
index 23c06f749..6154e2764 100644
--- a/tests/stdlib/cmp-int32.dora
+++ b/tests/stdlib/cmp-int32.dora
@@ -1,4 +1,5 @@
 use std::traits::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(0i32.cmp(1i32) == Ordering::Less);
diff --git a/tests/stdlib/cmp-int64.dora b/tests/stdlib/cmp-int64.dora
index 1acfa4fb0..ea88f16f7 100644
--- a/tests/stdlib/cmp-int64.dora
+++ b/tests/stdlib/cmp-int64.dora
@@ -1,4 +1,5 @@
 use std::traits::Ordering;
+use std::traits::Comparable;
 
 fn main() {
     assert(0.cmp(1) == Ordering::Less);
diff --git a/tests/stdlib/hashmap-retainif1.dora b/tests/stdlib/hashmap-retainif1.dora
index aba88e0ea..f58af7098 100644
--- a/tests/stdlib/hashmap-retainif1.dora
+++ b/tests/stdlib/hashmap-retainif1.dora
@@ -1,4 +1,6 @@
 use std::HashMap;
+use std::traits::{IntoIterator, Iterator};
+use std::string::Stringable;
 
 fn main() {
     let map = HashMap[Int, String]::new();
diff --git a/tests/stdlib/hashmap1.dora b/tests/stdlib/hashmap1.dora
index 3feb95847..f12db19e3 100644
--- a/tests/stdlib/hashmap1.dora
+++ b/tests/stdlib/hashmap1.dora
@@ -1,5 +1,6 @@
 use std::BitSet;
 use std::HashMap;
+use std::traits::Not;
 
 fn main() {
     let map = HashMap[Int32, String]::new();
diff --git a/tests/stdlib/hashmap2.dora b/tests/stdlib/hashmap2.dora
index a22ce631c..a69abf253 100644
--- a/tests/stdlib/hashmap2.dora
+++ b/tests/stdlib/hashmap2.dora
@@ -1,4 +1,6 @@
 use std::HashMap;
+use std::string::Stringable;
+use std::traits::Not;
 
 fn main() {
     let map = HashMap[Int32, String]::new();
diff --git a/tests/stdlib/hashset1.dora b/tests/stdlib/hashset1.dora
index ed20781a1..2cabf8763 100644
--- a/tests/stdlib/hashset1.dora
+++ b/tests/stdlib/hashset1.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
     let set = std::HashSet[Int32]::new();
     set.insert(1i32);
diff --git a/tests/stdlib/hashset2.dora b/tests/stdlib/hashset2.dora
index 2c2435f75..d88fddc65 100644
--- a/tests/stdlib/hashset2.dora
+++ b/tests/stdlib/hashset2.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
     let set = std::HashSet[Int32]::new();
     assert(set.isEmpty());
diff --git a/tests/stdlib/int32.dora b/tests/stdlib/int32.dora
index 372500e0c..5aafa412c 100644
--- a/tests/stdlib/int32.dora
+++ b/tests/stdlib/int32.dora
@@ -1,3 +1,5 @@
+use std::traits::{Add, BitAnd, BitOr, BitXor, Div, Mod, Mul, Neg, Not, Sub};
+
 fn main() {
     let x = 1i32.neg();
     assert(x == (-1i32));
diff --git a/tests/stdlib/option2.dora b/tests/stdlib/option2.dora
index 7e91d18b5..bca91c1c0 100644
--- a/tests/stdlib/option2.dora
+++ b/tests/stdlib/option2.dora
@@ -1,3 +1,6 @@
+use std::traits::Equals;
+use std::string::Stringable;
+
 fn main() {
   let x = None[Int32];
   assert(x.isNone());
diff --git a/tests/stdlib/range1.dora b/tests/stdlib/range1.dora
index f595c1323..d24bfdc98 100644
--- a/tests/stdlib/range1.dora
+++ b/tests/stdlib/range1.dora
@@ -1,3 +1,5 @@
+use std::traits::{IntoIterator, Iterator};
+
 fn main() {
     let x = std::range(0, 5).iter();
 
diff --git a/tests/stdlib/result-contains.dora b/tests/stdlib/result-contains.dora
index c89826b5e..753b031cc 100644
--- a/tests/stdlib/result-contains.dora
+++ b/tests/stdlib/result-contains.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
   let ok = "ok";
   let ok1 = Result[String, Int32]::Ok(ok);
diff --git a/tests/stdlib/result-equals.dora b/tests/stdlib/result-equals.dora
index 4e9bee271..bf3d290f9 100644
--- a/tests/stdlib/result-equals.dora
+++ b/tests/stdlib/result-equals.dora
@@ -1,3 +1,5 @@
+use std::traits::{Equals, Not};
+
 fn main() {
   let ok = "ok";
   let ok1 = Result[String, Int32]::Ok(ok);
diff --git a/tests/stdlib/result-isErr.dora b/tests/stdlib/result-isErr.dora
index 918be278c..41558f2f6 100644
--- a/tests/stdlib/result-isErr.dora
+++ b/tests/stdlib/result-isErr.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
   assert(Result[Int32, String]::Ok(23i32).isErr().not());
   assert(Result[Int32, String]::Err("err").isErr());
diff --git a/tests/stdlib/result-isOk.dora b/tests/stdlib/result-isOk.dora
index 2dda5ae8f..0bf681dd8 100644
--- a/tests/stdlib/result-isOk.dora
+++ b/tests/stdlib/result-isOk.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
   assert(Result[Int32, String]::Ok(23i32).isOk());
   assert(Result[Int32, String]::Err("err").isOk().not());
diff --git a/tests/string/string-comparisons.dora b/tests/string/string-comparisons.dora
index 15553c055..a05b33d78 100644
--- a/tests/string/string-comparisons.dora
+++ b/tests/string/string-comparisons.dora
@@ -1,4 +1,4 @@
-use std::traits::Ordering;
+use std::traits::{Add, Comparable, Equals, Ordering};
 
 fn main() {
   let x = "hello";
diff --git a/tests/string/string-contains.dora b/tests/string/string-contains.dora
index cc9b77c50..4d2ad8337 100644
--- a/tests/string/string-contains.dora
+++ b/tests/string/string-contains.dora
@@ -1,3 +1,5 @@
+use std::traits::Not;
+
 fn main() {
   testBothEmpty();
   testNeedleEmpty();
diff --git a/tests/string/string-toString.dora b/tests/string/string-toString.dora
index d0494bc71..236daa280 100644
--- a/tests/string/string-toString.dora
+++ b/tests/string/string-toString.dora
@@ -1,3 +1,5 @@
+use std::string::Stringable;
+
 fn main() {
   assert(true.toString() == "true");
   assert(false.toString() == "false");
diff --git a/tests/string/template1.dora b/tests/string/template1.dora
index 715709483..31fc21b6d 100644
--- a/tests/string/template1.dora
+++ b/tests/string/template1.dora
@@ -1,3 +1,6 @@
+use std::string::Stringable;
+use std::traits::Not;
+
 fn main() {
     let x = "a${1}b${2}c${3}d";
     assert(x == "a1b2c3d");
diff --git a/tests/trait/trait-object-generic-ty1.dora b/tests/trait/trait-object-generic-ty1.dora
index 3fcfeef30..7e8262898 100644
--- a/tests/trait/trait-object-generic-ty1.dora
+++ b/tests/trait/trait-object-generic-ty1.dora
@@ -1,9 +1,9 @@
 trait Foo[T] {
-    fn getter(): T;
+    fn get(): T;
 }
 
 impl[T] Foo[T] for T {
-    fn getter(): T { self }
+    fn get(): T { self }
 }
 
 fn f(x: Int64): Foo[Int64] {
@@ -22,17 +22,17 @@ struct Bar { x: Int64, y: Int64 }
 
 fn main() {
     let foo = f(10);
-    assert(foo.getter() == 10);
+    assert(foo.get() == 10);
 
     let foo = f(64);
-    assert(foo.getter() == 64);
+    assert(foo.get() == 64);
 
     let msg = "test";
     let foo = g(msg);
-    assert(foo.getter() === msg);
+    assert(foo.get() === msg);
 
     let foo = h(Bar(x = 17, y = 42));
-    let result = foo.getter();
+    let result = foo.get();
     assert(result.x == 17);
     assert(result.y == 42);
 }
diff --git a/tests/vec/vec-enumerate2.dora b/tests/vec/vec-enumerate2.dora
index 99b80fe43..0a403d8e0 100644
--- a/tests/vec/vec-enumerate2.dora
+++ b/tests/vec/vec-enumerate2.dora
@@ -1,3 +1,5 @@
+use std::traits::Iterator;
+
 fn main() {
     iterateManually();
     iterateWithForIn();
diff --git a/tests/vec/vec-equals.dora b/tests/vec/vec-equals.dora
index 7faa4ae38..cecedb479 100644
--- a/tests/vec/vec-equals.dora
+++ b/tests/vec/vec-equals.dora
@@ -1,3 +1,5 @@
+use std::traits::Equals;
+
 fn main() {
   assert(Vec[Int32]::new() == Vec[Int32]::new());
   assert(Vec[Int32]::new().equals(Vec[Int32]::new()));
diff --git a/tests/vec/vec-for1.dora b/tests/vec/vec-for1.dora
index 4913355ec..4d95dcacb 100644
--- a/tests/vec/vec-for1.dora
+++ b/tests/vec/vec-for1.dora
@@ -1,3 +1,5 @@
+use std::traits::IntoIterator;
+
 fn main() {
     assert(mysum1(Vec[Int32]::new()) == 0i32);
     assert(mysum1(Vec[Int32]::new(1i32)) == 1i32);
diff --git a/tests/vec/vec2.dora b/tests/vec/vec2.dora
index e9c79d51a..1c5d24af9 100644
--- a/tests/vec/vec2.dora
+++ b/tests/vec/vec2.dora
@@ -1,4 +1,5 @@
 //= stdout "321"
+use std::string::Stringable;
 
 fn main() {
     let x = Vec[String]::new();
diff --git a/tests/whiteboard/fizzbuzz.dora b/tests/whiteboard/fizzbuzz.dora
index 67ee9abdf..61f034415 100644
--- a/tests/whiteboard/fizzbuzz.dora
+++ b/tests/whiteboard/fizzbuzz.dora
@@ -1,4 +1,5 @@
 //= stdout file
+use std::string::Stringable;
 
 fn main() {
     let mut i = 1i32;
diff --git a/tests/whiteboard/sieve.dora b/tests/whiteboard/sieve.dora
index ad5762ad7..b09df5648 100644
--- a/tests/whiteboard/sieve.dora
+++ b/tests/whiteboard/sieve.dora
@@ -1,4 +1,5 @@
 //= stdout file
+use std::string::Stringable;
 
 fn main() {
     let primes = sieve(100);