src/librustc/middle/check_static.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Verifies that the types and values of static items
  12 // are safe. The rules enforced by this module are:
  13 //
  14 // - For each *mutable* static item, it checks that its **type**:
  15 //     - doesn't have a destructor
  16 //     - doesn't own an owned pointer
  17 //
  18 // - For each *immutable* static item, it checks that its **value**:
  19 //       - doesn't own owned, managed pointers
  20 //       - doesn't contain a struct literal or a call to an enum variant / struct constructor where
  21 //           - the type of the struct/enum has a dtor
  22 //
  23 // Rules Enforced Elsewhere:
  24 // - It's not possible to take the address of a static item with unsafe interior. This is enforced
  25 // by borrowck::gather_loans
  26
  27 use middle::ty;
  28
  29 use syntax::ast;
  30 use syntax::codemap::Span;
  31 use syntax::visit::Visitor;
  32 use syntax::visit;
  33 use syntax::print::pprust;
  34
  35
  36 fn safe_type_for_static_mut(cx: &ty::ctxt, e: &ast::Expr) -> Option<~str> {
  37     let node_ty = ty::node_id_to_type(cx, e.id);
  38     let tcontents = ty::type_contents(cx, node_ty);
  39     debug!("safe_type_for_static_mut(dtor={}, managed={}, owned={})",
  40            tcontents.has_dtor(), tcontents.owns_managed(), tcontents.owns_owned())
  41
  42     let suffix = if tcontents.has_dtor() {
  43         "destructors"
  44     } else if tcontents.owns_managed() {
  45         "managed pointers"
  46     } else if tcontents.owns_owned() {
  47         "owned pointers"
  48     } else {
  49         return None;
  50     };
  51
  52     Some(format!("mutable static items are not allowed to have {}", suffix))
  53 }
  54
  55 struct CheckStaticVisitor<'a> {
  56     tcx: &'a ty::ctxt,
  57 }
  58
  59 pub fn check_crate(tcx: &ty::ctxt, krate: &ast::Crate) {
  60     visit::walk_crate(&mut CheckStaticVisitor { tcx: tcx }, krate, false)
  61 }
  62
  63 impl<'a> CheckStaticVisitor<'a> {
  64     fn report_error(&self, span: Span, result: Option<~str>) -> bool {
  65         match result {
  66             None => { false }
  67             Some(msg) => {
  68                 self.tcx.sess.span_err(span, msg);
  69                 true
  70             }
  71         }
  72     }
  73 }
  74
  75 impl<'a> Visitor<bool> for CheckStaticVisitor<'a> {
  76
  77     fn visit_item(&mut self, i: &ast::Item, _is_const: bool) {
  78         debug!("visit_item(item={})", pprust::item_to_str(i));
  79         match i.node {
  80             ast::ItemStatic(_, mutability, expr) => {
  81                 match mutability {
  82                     ast::MutImmutable => {
  83                         self.visit_expr(expr, true);
  84                     }
  85                     ast::MutMutable => {
  86                         self.report_error(expr.span, safe_type_for_static_mut(self.tcx, expr));
  87                     }
  88                 }
  89             }
  90             _ => { visit::walk_item(self, i, false) }
  91         }
  92     }
  93
  94     /// This method is used to enforce the constraints on
  95     /// immutable static items. It walks through the *value*
  96     /// of the item walking down the expression and evaluating
  97     /// every nested expression. if the expression is not part
  98     /// of a static item, this method does nothing but walking
  99     /// down through it.
 100     fn visit_expr(&mut self, e: &ast::Expr, is_const: bool) {
 101         debug!("visit_expr(expr={})", pprust::expr_to_str(e));
 102
 103         if !is_const {
 104             return visit::walk_expr(self, e, is_const);
 105         }
 106
 107         match e.node {
 108             ast::ExprField(..) | ast::ExprVec(..) |
 109             ast::ExprBlock(..) | ast::ExprTup(..) |
 110             ast::ExprVstore(_, ast::ExprVstoreSlice) => {
 111                 visit::walk_expr(self, e, is_const);
 112             }
 113             ast::ExprVstore(_, ast::ExprVstoreMutSlice) => {
 114                 self.tcx.sess.span_err(e.span,
 115                                        "static items are not allowed to have mutable slices");
 116            },
 117             ast::ExprUnary(ast::UnBox, _) => {
 118                 self.tcx.sess.span_err(e.span,
 119                                    "static items are not allowed to have managed pointers");
 120             }
 121             ast::ExprBox(..) |
 122             ast::ExprUnary(ast::UnUniq, _) |
 123             ast::ExprVstore(_, ast::ExprVstoreUniq) => {
 124                 self.tcx.sess.span_err(e.span,
 125                                    "static items are not allowed to have owned pointers");
 126             }
 127             _ => {
 128                 let node_ty = ty::node_id_to_type(self.tcx, e.id);
 129
 130                 match ty::get(node_ty).sty {
 131                     ty::ty_struct(did, _) |
 132                     ty::ty_enum(did, _) => {
 133                         if ty::has_dtor(self.tcx, did) {
 134                             self.report_error(e.span,
 135                              Some("static items are not allowed to have destructors".to_owned()));
 136                             return;
 137                         }
 138                     }
 139                     _ => {}
 140                 }
 141                 visit::walk_expr(self, e, is_const);
 142             }
 143         }
 144     }
 145 }