---

yaml
---
r: 65206
b: refs/heads/master
c: f517ed0
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5118d2f84a4c4a8bf00d7fb9e06609877bf821e7
+refs/heads/master: f517ed0b08f5a1cc9b65ac0e57dbfaaefcbf002a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/rust.md

@@ -1426,6 +1426,7 @@ names are effectively reserved. Some significant attributes include:
 by the compiler can be found via `rustc -W help`.
 * The `deriving` attribute, for automatically generating
   implementations of certain traits.
+* The `static_assert` attribute, for asserting that a static bool is true at compiletime
 
 Other attributes may be added or removed during development of the language.
 

trunk/src/librustc/middle/trans/base.rs

@@ -2147,7 +2147,26 @@ pub fn trans_item(ccx: @CrateContext, item: &ast::item) {
             trans_enum_def(ccx, enum_definition, item.id, vi, &mut i);
         }
       }
-      ast::item_const(_, expr) => consts::trans_const(ccx, expr, item.id),
+      ast::item_const(_, expr) => {
+          consts::trans_const(ccx, expr, item.id);
+          // Do static_assert checking. It can't really be done much earlier because we need to get
+          // the value of the bool out of LLVM
+          for item.attrs.each |attr| {
+              match attr.node.value.node {
+                  ast::meta_word(x) => {
+                      if x.slice(0, x.len()) == "static_assert" {
+                          let v = ccx.const_values.get_copy(&item.id);
+                          unsafe {
+                              if !(llvm::LLVMConstIntGetZExtValue(v) as bool) {
+                                  ccx.sess.span_fatal(expr.span, "static assertion failed");
+                              }
+                          }
+                      }
+                  },
+                  _ => ()
+              }
+          }
+      },
       ast::item_foreign_mod(ref foreign_mod) => {
         foreign::trans_foreign_mod(ccx, path, foreign_mod);
       }

trunk/src/libsyntax/parse/parser.rs

@@ -4186,10 +4186,10 @@ pub impl Parser {
             return iovi_foreign_item(item);
         }
         if (self.is_keyword("fn") || self.is_keyword("pure") ||
-             self.is_keyword("unsafe")) {
+                self.is_keyword("unsafe")) {
             // FOREIGN FUNCTION ITEM
-                let item = self.parse_item_foreign_fn(attrs);
-                return iovi_foreign_item(item);
+            let item = self.parse_item_foreign_fn(attrs);
+            return iovi_foreign_item(item);
         }
         self.parse_macro_use_or_failure(attrs,macros_allowed,lo,visibility)
     }
@@ -4504,7 +4504,12 @@ pub impl Parser {
         let mut foreign_items = ~[];
         loop {
             match self.parse_foreign_item(/*bad*/ copy attrs, macros_allowed) {
-                iovi_none => break,
+                iovi_none => {
+                    if *self.token == token::RBRACE {
+                        break
+                    }
+                    self.unexpected();
+                },
                 iovi_view_item(view_item) => {
                     // I think this can't occur:
                     self.span_err(view_item.span,

trunk/src/test/compile-fail/extern-no-fn.rs

@@ -0,0 +1,17 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern:unexpected token
+extern {
+    f();
+}
+
+fn main() {
+}

trunk/src/test/compile-fail/static-assert.rs

@@ -0,0 +1,5 @@
+#[static_assert]
+static a: bool = false; //~ ERROR static assertion failed
+
+fn main() {
+}

trunk/src/test/compile-fail/static-assert2.rs

@@ -0,0 +1,4 @@
+#[static_assert]
+static e: bool = 1 == 2; //~ ERROR static assertion failed
+
+fn main() {}

trunk/src/test/run-pass/issue-4107.rs

@@ -0,0 +1,33 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn main() {
+    let id: &Mat2<float> = &Matrix::identity();
+}
+
+pub trait Index<Index,Result> { }
+pub trait Dimensional<T>: Index<uint, T> { }
+
+pub struct Mat2<T> { x: () }
+pub struct Vec2<T> { x: () }
+
+impl<T> Dimensional<Vec2<T>> for Mat2<T> { }
+impl<T> Index<uint, Vec2<T>> for Mat2<T> { }
+
+impl<T> Dimensional<T> for Vec2<T> { }
+impl<T> Index<uint, T> for Vec2<T> { }
+
+pub trait Matrix<T,V>: Dimensional<V> {
+    fn identity() -> Self;
+}
+
+impl<T> Matrix<T, Vec2<T>> for Mat2<T> {
+    fn identity() -> Mat2<T> { Mat2{ x: () } }
+}

trunk/src/test/run-pass/static-assert.rs

@@ -0,0 +1,14 @@
+#[static_assert]
+static b: bool = true;
+
+#[static_assert]
+static c: bool = 1 == 1;
+
+#[static_assert]
+static d: bool = 1 != 2;
+
+#[static_assert]
+static f: bool = (4/2) == 2;
+
+fn main() {
+}