2012-12-03 18:48:01 -06:00
|
|
|
// 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.
|
|
|
|
|
2013-01-08 21:37:25 -06:00
|
|
|
use core::prelude::*;
|
2013-01-07 16:16:52 -06:00
|
|
|
|
2012-10-15 16:56:42 -05:00
|
|
|
use driver::session::Session;
|
2012-12-23 16:41:37 -06:00
|
|
|
use middle::resolve;
|
|
|
|
use middle::ty;
|
|
|
|
use middle::typeck;
|
|
|
|
use util::ppaux;
|
|
|
|
|
|
|
|
use core::dvec::DVec;
|
|
|
|
use core::option;
|
2013-02-01 01:13:36 -06:00
|
|
|
use std::oldmap::HashMap;
|
2012-12-23 16:41:37 -06:00
|
|
|
use syntax::ast::*;
|
2013-01-30 11:56:33 -06:00
|
|
|
use syntax::codemap;
|
2012-12-23 16:41:37 -06:00
|
|
|
use syntax::{visit, ast_util, ast_map};
|
2011-11-08 20:26:02 -06:00
|
|
|
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn check_crate(sess: Session,
|
|
|
|
crate: @crate,
|
|
|
|
ast_map: ast_map::map,
|
|
|
|
def_map: resolve::DefMap,
|
|
|
|
method_map: typeck::method_map,
|
|
|
|
tcx: ty::ctxt) {
|
2013-01-08 16:00:45 -06:00
|
|
|
visit::visit_crate(*crate, false, visit::mk_vt(@visit::Visitor {
|
2012-06-30 18:19:07 -05:00
|
|
|
visit_item: |a,b,c| check_item(sess, ast_map, def_map, a, b, c),
|
2011-12-02 06:42:51 -06:00
|
|
|
visit_pat: check_pat,
|
2012-06-30 18:19:07 -05:00
|
|
|
visit_expr: |a,b,c|
|
2012-09-04 15:29:32 -05:00
|
|
|
check_expr(sess, def_map, method_map, tcx, a, b, c),
|
|
|
|
.. *visit::default_visitor()
|
2011-12-02 06:42:51 -06:00
|
|
|
}));
|
|
|
|
sess.abort_if_errors();
|
2011-11-08 20:26:02 -06:00
|
|
|
}
|
|
|
|
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn check_item(sess: Session,
|
|
|
|
ast_map: ast_map::map,
|
|
|
|
def_map: resolve::DefMap,
|
|
|
|
it: @item,
|
|
|
|
&&_is_const: bool,
|
|
|
|
v: visit::vt<bool>) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match it.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
item_const(_, ex) => {
|
2012-11-29 19:51:16 -06:00
|
|
|
(v.visit_expr)(ex, true, v);
|
2012-04-04 18:12:57 -05:00
|
|
|
check_item_recursion(sess, ast_map, def_map, it);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
item_enum(ref enum_definition, _) => {
|
|
|
|
for (*enum_definition).variants.each |var| {
|
2012-09-21 21:37:57 -05:00
|
|
|
do option::iter(&var.node.disr_expr) |ex| {
|
2012-11-29 19:51:16 -06:00
|
|
|
(v.visit_expr)(*ex, true, v);
|
2012-01-16 03:36:47 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => visit::visit_item(it, false, v)
|
2011-11-08 20:26:02 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn check_pat(p: @pat, &&_is_const: bool, v: visit::vt<bool>) {
|
2011-12-02 06:42:51 -06:00
|
|
|
fn is_str(e: @expr) -> bool {
|
2012-08-06 14:34:08 -05:00
|
|
|
match e.node {
|
2013-01-15 15:51:43 -06:00
|
|
|
expr_vstore(
|
2013-01-30 11:56:33 -06:00
|
|
|
@expr { node: expr_lit(@codemap::spanned {
|
|
|
|
node: lit_str(_),
|
|
|
|
_}),
|
|
|
|
_ },
|
2013-01-15 15:51:43 -06:00
|
|
|
expr_vstore_uniq
|
|
|
|
) => true,
|
|
|
|
_ => false
|
2012-07-12 14:14:08 -05:00
|
|
|
}
|
2011-12-02 06:42:51 -06:00
|
|
|
}
|
2012-08-06 14:34:08 -05:00
|
|
|
match p.node {
|
2012-07-14 15:55:41 -05:00
|
|
|
// Let through plain ~-string literals here
|
2012-11-29 19:51:16 -06:00
|
|
|
pat_lit(a) => if !is_str(a) { (v.visit_expr)(a, true, v); },
|
2012-08-03 21:59:04 -05:00
|
|
|
pat_range(a, b) => {
|
2012-11-29 19:51:16 -06:00
|
|
|
if !is_str(a) { (v.visit_expr)(a, true, v); }
|
|
|
|
if !is_str(b) { (v.visit_expr)(b, true, v); }
|
2011-12-02 06:42:51 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => visit::visit_pat(p, false, v)
|
2011-12-02 06:42:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn check_expr(sess: Session,
|
|
|
|
def_map: resolve::DefMap,
|
|
|
|
method_map: typeck::method_map,
|
|
|
|
tcx: ty::ctxt,
|
|
|
|
e: @expr,
|
|
|
|
&&is_const: bool,
|
|
|
|
v: visit::vt<bool>) {
|
2011-12-02 06:42:51 -06:00
|
|
|
if is_const {
|
2012-08-06 14:34:08 -05:00
|
|
|
match e.node {
|
2011-12-02 06:42:51 -06:00
|
|
|
expr_unary(box(_), _) | expr_unary(uniq(_), _) |
|
2012-08-03 21:59:04 -05:00
|
|
|
expr_unary(deref, _) => {
|
2011-12-02 06:42:51 -06:00
|
|
|
sess.span_err(e.span,
|
2012-07-14 00:57:48 -05:00
|
|
|
~"disallowed operator in constant expression");
|
2012-08-01 19:30:05 -05:00
|
|
|
return;
|
2011-12-02 06:42:51 -06:00
|
|
|
}
|
2013-01-30 11:56:33 -06:00
|
|
|
expr_lit(@codemap::spanned {node: lit_str(_), _}) => { }
|
2012-08-03 21:59:04 -05:00
|
|
|
expr_binary(_, _, _) | expr_unary(_, _) => {
|
2013-02-08 16:08:02 -06:00
|
|
|
if method_map.contains_key(&e.id) {
|
2012-07-14 00:57:48 -05:00
|
|
|
sess.span_err(e.span, ~"user-defined operators are not \
|
2012-01-26 05:26:14 -06:00
|
|
|
allowed in constant expressions");
|
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
expr_lit(_) => (),
|
|
|
|
expr_cast(_, _) => {
|
2012-03-14 12:04:03 -05:00
|
|
|
let ety = ty::expr_ty(tcx, e);
|
|
|
|
if !ty::type_is_numeric(ety) {
|
2012-07-14 00:57:48 -05:00
|
|
|
sess.span_err(e.span, ~"can not cast to `" +
|
2012-12-23 16:41:37 -06:00
|
|
|
ppaux::ty_to_str(tcx, ety) +
|
2012-07-14 00:57:48 -05:00
|
|
|
~"` in a constant expression");
|
2012-03-14 12:04:03 -05:00
|
|
|
}
|
|
|
|
}
|
2012-11-06 19:13:52 -06:00
|
|
|
expr_path(pth) => {
|
|
|
|
// NB: In the future you might wish to relax this slightly
|
|
|
|
// to handle on-demand instantiation of functions via
|
|
|
|
// foo::<bar> in a const. Currently that is only done on
|
|
|
|
// a path in trans::callee that only works in block contexts.
|
|
|
|
if pth.types.len() != 0 {
|
|
|
|
sess.span_err(
|
|
|
|
e.span, ~"paths in constants may only refer to \
|
|
|
|
items without type parameters");
|
|
|
|
}
|
2013-02-05 21:41:45 -06:00
|
|
|
match def_map.find(&e.id) {
|
2013-02-13 13:46:14 -06:00
|
|
|
Some(def_variant(_, _)) |
|
|
|
|
Some(def_struct(_)) => { }
|
|
|
|
|
|
|
|
Some(def_const(def_id)) |
|
|
|
|
Some(def_fn(def_id, _)) => {
|
2012-04-04 17:02:25 -05:00
|
|
|
if !ast_util::is_local(def_id) {
|
|
|
|
sess.span_err(
|
2012-07-14 00:57:48 -05:00
|
|
|
e.span, ~"paths in constants may only refer to \
|
2013-02-13 13:46:14 -06:00
|
|
|
crate-local constants or functions");
|
2012-04-04 17:02:25 -05:00
|
|
|
}
|
|
|
|
}
|
2012-11-30 18:29:28 -06:00
|
|
|
Some(def) => {
|
|
|
|
debug!("(checking const) found bad def: %?", def);
|
2012-04-04 17:02:25 -05:00
|
|
|
sess.span_err(
|
2012-07-14 00:57:48 -05:00
|
|
|
e.span,
|
2012-11-30 18:29:28 -06:00
|
|
|
fmt!("paths in constants may only refer to \
|
|
|
|
constants or functions"));
|
2012-04-04 17:02:25 -05:00
|
|
|
}
|
2012-11-30 18:29:28 -06:00
|
|
|
None => {
|
|
|
|
sess.span_bug(e.span, ~"unbound path in const?!");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-01-31 19:12:29 -06:00
|
|
|
expr_call(callee, _, NoSugar) => {
|
2013-02-05 21:41:45 -06:00
|
|
|
match def_map.find(&callee.id) {
|
2012-12-10 15:47:54 -06:00
|
|
|
Some(def_struct(*)) => {} // OK.
|
2012-12-30 22:39:15 -06:00
|
|
|
Some(def_variant(*)) => {} // OK.
|
2012-11-30 18:29:28 -06:00
|
|
|
_ => {
|
|
|
|
sess.span_err(
|
|
|
|
e.span,
|
|
|
|
~"function calls in constants are limited to \
|
2012-12-30 22:39:15 -06:00
|
|
|
struct and enum constructors");
|
2012-11-30 18:29:28 -06:00
|
|
|
}
|
2012-04-04 17:02:25 -05:00
|
|
|
}
|
|
|
|
}
|
2012-10-27 19:14:09 -05:00
|
|
|
expr_paren(e) => { check_expr(sess, def_map, method_map,
|
|
|
|
tcx, e, is_const, v); }
|
2012-09-11 23:25:01 -05:00
|
|
|
expr_vstore(_, expr_vstore_slice) |
|
|
|
|
expr_vstore(_, expr_vstore_fixed(_)) |
|
2012-08-03 23:44:42 -05:00
|
|
|
expr_vec(_, m_imm) |
|
2012-08-03 20:07:45 -05:00
|
|
|
expr_addr_of(m_imm, _) |
|
2012-08-08 21:41:50 -05:00
|
|
|
expr_field(*) |
|
|
|
|
expr_index(*) |
|
2012-07-31 20:34:36 -05:00
|
|
|
expr_tup(*) |
|
2012-08-07 19:11:43 -05:00
|
|
|
expr_struct(*) |
|
2012-08-03 21:59:04 -05:00
|
|
|
expr_rec(*) => { }
|
|
|
|
expr_addr_of(*) => {
|
2012-08-03 20:07:45 -05:00
|
|
|
sess.span_err(
|
|
|
|
e.span,
|
|
|
|
~"borrowed pointers in constants may only refer to \
|
|
|
|
immutable values");
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {
|
2011-12-02 06:42:51 -06:00
|
|
|
sess.span_err(e.span,
|
2012-07-14 00:57:48 -05:00
|
|
|
~"constant contains unimplemented expression type");
|
2012-08-01 19:30:05 -05:00
|
|
|
return;
|
2011-11-09 03:42:30 -06:00
|
|
|
}
|
|
|
|
}
|
2011-11-08 20:26:02 -06:00
|
|
|
}
|
2012-08-06 14:34:08 -05:00
|
|
|
match e.node {
|
2013-01-30 11:56:33 -06:00
|
|
|
expr_lit(@codemap::spanned {node: lit_int(v, t), _}) => {
|
2011-12-07 14:53:05 -06:00
|
|
|
if t != ty_char {
|
|
|
|
if (v as u64) > ast_util::int_ty_max(
|
2012-01-29 20:33:08 -06:00
|
|
|
if t == ty_i { sess.targ_cfg.int_type } else { t }) {
|
2012-07-14 00:57:48 -05:00
|
|
|
sess.span_err(e.span, ~"literal out of range for its type");
|
2011-12-07 14:53:05 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-01-30 11:56:33 -06:00
|
|
|
expr_lit(@codemap::spanned {node: lit_uint(v, t), _}) => {
|
2011-12-07 14:53:05 -06:00
|
|
|
if v > ast_util::uint_ty_max(
|
2012-01-29 20:33:08 -06:00
|
|
|
if t == ty_u { sess.targ_cfg.uint_type } else { t }) {
|
2012-07-14 00:57:48 -05:00
|
|
|
sess.span_err(e.span, ~"literal out of range for its type");
|
2011-12-07 14:53:05 -06:00
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-12-07 14:53:05 -06:00
|
|
|
}
|
2011-12-02 06:42:51 -06:00
|
|
|
visit::visit_expr(e, is_const, v);
|
2011-11-08 20:26:02 -06:00
|
|
|
}
|
|
|
|
|
2012-04-04 18:12:57 -05:00
|
|
|
// Make sure a const item doesn't recursively refer to itself
|
2012-06-07 15:49:01 -05:00
|
|
|
// FIXME: Should use the dependency graph when it's available (#1356)
|
2013-01-30 15:44:24 -06:00
|
|
|
pub fn check_item_recursion(sess: Session,
|
|
|
|
ast_map: ast_map::map,
|
|
|
|
def_map: resolve::DefMap,
|
|
|
|
it: @item) {
|
2012-04-04 18:12:57 -05:00
|
|
|
type env = {
|
|
|
|
root_it: @item,
|
2012-10-15 16:56:42 -05:00
|
|
|
sess: Session,
|
2012-04-04 18:12:57 -05:00
|
|
|
ast_map: ast_map::map,
|
2012-08-29 15:26:26 -05:00
|
|
|
def_map: resolve::DefMap,
|
2012-08-14 18:54:13 -05:00
|
|
|
idstack: @DVec<node_id>,
|
2012-04-04 18:12:57 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
let env = {
|
|
|
|
root_it: it,
|
|
|
|
sess: sess,
|
|
|
|
ast_map: ast_map,
|
|
|
|
def_map: def_map,
|
2012-08-27 16:22:25 -05:00
|
|
|
idstack: @DVec()
|
2012-04-04 18:12:57 -05:00
|
|
|
};
|
|
|
|
|
2013-01-08 16:00:45 -06:00
|
|
|
let visitor = visit::mk_vt(@visit::Visitor {
|
2012-04-04 18:12:57 -05:00
|
|
|
visit_item: visit_item,
|
2012-09-04 15:29:32 -05:00
|
|
|
visit_expr: visit_expr,
|
|
|
|
.. *visit::default_visitor()
|
2012-04-04 18:12:57 -05:00
|
|
|
});
|
2012-11-29 19:51:16 -06:00
|
|
|
(visitor.visit_item)(it, env, visitor);
|
2012-04-04 18:12:57 -05:00
|
|
|
|
|
|
|
fn visit_item(it: @item, &&env: env, v: visit::vt<env>) {
|
2012-09-25 19:39:22 -05:00
|
|
|
if (*env.idstack).contains(&(it.id)) {
|
2012-07-14 00:57:48 -05:00
|
|
|
env.sess.span_fatal(env.root_it.span, ~"recursive constant");
|
2012-04-04 18:12:57 -05:00
|
|
|
}
|
2012-06-04 10:04:43 -05:00
|
|
|
(*env.idstack).push(it.id);
|
2012-04-04 18:12:57 -05:00
|
|
|
visit::visit_item(it, env, v);
|
2012-06-04 10:04:43 -05:00
|
|
|
(*env.idstack).pop();
|
2012-04-04 18:12:57 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn visit_expr(e: @expr, &&env: env, v: visit::vt<env>) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match e.node {
|
2012-08-26 14:12:05 -05:00
|
|
|
expr_path(*) => {
|
2013-02-05 21:41:45 -06:00
|
|
|
match env.def_map.find(&e.id) {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(def_const(def_id)) => {
|
2013-02-05 21:41:45 -06:00
|
|
|
match env.ast_map.get(&def_id.node) {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast_map::node_item(it, _) => {
|
2012-11-29 19:51:16 -06:00
|
|
|
(v.visit_item)(it, env, v);
|
2012-04-04 18:12:57 -05:00
|
|
|
}
|
2013-01-31 19:51:01 -06:00
|
|
|
_ => die!(~"const not bound to an item")
|
2012-04-04 18:12:57 -05:00
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2012-04-04 18:12:57 -05:00
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2012-04-04 18:12:57 -05:00
|
|
|
}
|
|
|
|
visit::visit_expr(e, env, v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-08 20:26:02 -06:00
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|