rust/src/librustc/middle/lang_items.rs

350 lines
11 KiB
Rust
Raw Normal View History

// 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.
// Detecting language items.
//
// Language items are items that represent concepts intrinsic to the language
// itself. Examples are:
//
2012-12-11 15:50:04 -06:00
// * Traits that specify "kinds"; e.g. "const", "copy", "owned".
//
// * Traits that represent operators; e.g. "add", "sub", "index".
//
// * Functions called by the compiler itself.
use driver::session::Session;
use metadata::csearch::{each_lang_item, get_item_attrs};
2012-09-04 13:54:36 -05:00
use metadata::cstore::{iter_crate_data};
use metadata::decoder::{dl_def, dl_field, dl_impl};
use syntax::ast::{crate, def_fn, def_id, def_ty, lit_str, meta_item};
use syntax::ast::{meta_list, meta_name_value, meta_word};
2012-09-04 13:54:36 -05:00
use syntax::ast_util::{local_def};
use syntax::visit::{default_simple_visitor, mk_simple_visitor};
use syntax::visit::{visit_crate, visit_item};
use core::ptr;
use std::map::HashMap;
2012-09-04 13:54:36 -05:00
use str_eq = str::eq;
pub enum LangItem {
ConstTraitLangItem, // 0
CopyTraitLangItem, // 1
OwnedTraitLangItem, // 2
DurableTraitLangItem, // 3
DropTraitLangItem, // 4
AddTraitLangItem, // 5
SubTraitLangItem, // 6
MulTraitLangItem, // 7
DivTraitLangItem, // 8
ModuloTraitLangItem, // 9
NegTraitLangItem, // 10
BitXorTraitLangItem, // 11
BitAndTraitLangItem, // 12
BitOrTraitLangItem, // 13
ShlTraitLangItem, // 14
ShrTraitLangItem, // 15
IndexTraitLangItem, // 16
EqTraitLangItem, // 17
OrdTraitLangItem, // 18
StrEqFnLangItem, // 19
UniqStrEqFnLangItem, // 20
AnnihilateFnLangItem, // 21
LogTypeFnLangItem, // 22
}
2012-08-15 20:46:55 -05:00
struct LanguageItems {
items: [ Option<def_id> * 23 ]
}
impl LanguageItems {
static pub fn new() -> LanguageItems {
LanguageItems {
items: [ None, ..23 ]
}
}
fn each_item(&self, f: &fn(def_id: def_id, i: uint) -> bool) {
for self.items.eachi |i, &item| {
if !f(item.get(), i) {
break;
}
}
}
static pub fn item_name(index: uint) -> &static/str {
match index {
0 => "const",
1 => "copy",
2 => "owned",
3 => "durable",
4 => "drop",
5 => "add",
6 => "sub",
7 => "mul",
8 => "div",
9 => "modulo",
10 => "neg",
11 => "bitxor",
12 => "bitand",
13 => "bitor",
14 => "shl",
15 => "shr",
16 => "index",
17 => "eq",
18 => "ord",
19 => "str_eq",
20 => "uniq_str_eq",
21 => "annihilate",
22 => "log_type",
_ => "???"
}
}
// XXX: Method macros sure would be nice here.
pub fn const_trait(&const self) -> def_id {
self.items[ConstTraitLangItem as uint].get()
}
pub fn copy_trait(&const self) -> def_id {
self.items[CopyTraitLangItem as uint].get()
}
pub fn owned_trait(&const self) -> def_id {
self.items[OwnedTraitLangItem as uint].get()
}
pub fn durable_trait(&const self) -> def_id {
self.items[DurableTraitLangItem as uint].get()
}
pub fn drop_trait(&const self) -> def_id {
self.items[DropTraitLangItem as uint].get()
}
pub fn add_trait(&const self) -> def_id {
self.items[AddTraitLangItem as uint].get()
}
pub fn sub_trait(&const self) -> def_id {
self.items[SubTraitLangItem as uint].get()
}
pub fn mul_trait(&const self) -> def_id {
self.items[MulTraitLangItem as uint].get()
}
pub fn div_trait(&const self) -> def_id {
self.items[DivTraitLangItem as uint].get()
}
pub fn modulo_trait(&const self) -> def_id {
self.items[ModuloTraitLangItem as uint].get()
}
pub fn neg_trait(&const self) -> def_id {
self.items[NegTraitLangItem as uint].get()
}
pub fn bitxor_trait(&const self) -> def_id {
self.items[BitXorTraitLangItem as uint].get()
}
pub fn bitand_trait(&const self) -> def_id {
self.items[BitAndTraitLangItem as uint].get()
}
pub fn bitor_trait(&const self) -> def_id {
self.items[BitOrTraitLangItem as uint].get()
}
pub fn shl_trait(&const self) -> def_id {
self.items[ShlTraitLangItem as uint].get()
}
pub fn shr_trait(&const self) -> def_id {
self.items[ShrTraitLangItem as uint].get()
}
pub fn index_trait(&const self) -> def_id {
self.items[IndexTraitLangItem as uint].get()
}
pub fn eq_trait(&const self) -> def_id {
self.items[EqTraitLangItem as uint].get()
}
pub fn ord_trait(&const self) -> def_id {
self.items[OrdTraitLangItem as uint].get()
}
2012-09-05 17:58:43 -05:00
pub fn str_eq_fn(&const self) -> def_id {
self.items[StrEqFnLangItem as uint].get()
}
pub fn uniq_str_eq_fn(&const self) -> def_id {
self.items[UniqStrEqFnLangItem as uint].get()
}
pub fn annihilate_fn(&const self) -> def_id {
self.items[AnnihilateFnLangItem as uint].get()
}
pub fn log_type_fn(&const self) -> def_id {
self.items[LogTypeFnLangItem as uint].get()
}
}
fn LanguageItemCollector(crate: @crate,
session: Session,
items: &r/mut LanguageItems)
-> LanguageItemCollector/&r {
let item_refs = HashMap();
2012-09-05 17:58:43 -05:00
item_refs.insert(~"const", ConstTraitLangItem as uint);
item_refs.insert(~"copy", CopyTraitLangItem as uint);
item_refs.insert(~"owned", OwnedTraitLangItem as uint);
item_refs.insert(~"durable", DurableTraitLangItem as uint);
item_refs.insert(~"drop", DropTraitLangItem as uint);
item_refs.insert(~"add", AddTraitLangItem as uint);
item_refs.insert(~"sub", SubTraitLangItem as uint);
item_refs.insert(~"mul", MulTraitLangItem as uint);
item_refs.insert(~"div", DivTraitLangItem as uint);
item_refs.insert(~"modulo", ModuloTraitLangItem as uint);
item_refs.insert(~"neg", NegTraitLangItem as uint);
item_refs.insert(~"bitxor", BitXorTraitLangItem as uint);
item_refs.insert(~"bitand", BitAndTraitLangItem as uint);
item_refs.insert(~"bitor", BitOrTraitLangItem as uint);
item_refs.insert(~"shl", ShlTraitLangItem as uint);
item_refs.insert(~"shr", ShrTraitLangItem as uint);
item_refs.insert(~"index", IndexTraitLangItem as uint);
item_refs.insert(~"eq", EqTraitLangItem as uint);
item_refs.insert(~"ord", OrdTraitLangItem as uint);
item_refs.insert(~"str_eq", StrEqFnLangItem as uint);
item_refs.insert(~"uniq_str_eq", UniqStrEqFnLangItem as uint);
item_refs.insert(~"annihilate", AnnihilateFnLangItem as uint);
item_refs.insert(~"log_type", LogTypeFnLangItem as uint);
2012-09-05 17:58:43 -05:00
LanguageItemCollector {
crate: crate,
session: session,
items: items,
item_refs: item_refs
}
}
2012-08-15 20:46:55 -05:00
struct LanguageItemCollector {
items: &mut LanguageItems,
2012-09-06 21:40:15 -05:00
crate: @crate,
session: Session,
item_refs: HashMap<~str,uint>,
}
impl LanguageItemCollector {
fn match_and_collect_meta_item(item_def_id: def_id,
meta_item: meta_item) {
2012-08-06 14:34:08 -05:00
match meta_item.node {
meta_name_value(ref key, literal) => {
2012-08-06 14:34:08 -05:00
match literal.node {
lit_str(value) => {
2012-12-04 23:13:02 -06:00
self.match_and_collect_item(item_def_id,
(*key),
*value);
}
2012-07-18 18:18:02 -05:00
_ => {} // Skip.
}
}
2012-07-18 18:18:02 -05:00
meta_word(*) | meta_list(*) => {} // Skip.
}
}
fn collect_item(item_index: uint, item_def_id: def_id) {
// Check for duplicates.
match self.items.items[item_index] {
Some(original_def_id) if original_def_id != item_def_id => {
self.session.err(fmt!("duplicate entry for `%s`",
LanguageItems::item_name(item_index)));
}
Some(_) | None => {
// OK.
}
}
// Matched.
self.items.items[item_index] = Some(item_def_id);
}
fn match_and_collect_item(item_def_id: def_id, key: ~str, value: ~str) {
if key != ~"lang" {
2012-08-01 19:30:05 -05:00
return; // Didn't match.
}
2012-08-06 14:34:08 -05:00
match self.item_refs.find(value) {
2012-08-20 14:23:37 -05:00
None => {
// Didn't match.
}
Some(item_index) => {
self.collect_item(item_index, item_def_id)
}
}
}
fn collect_local_language_items() {
let this = unsafe { ptr::addr_of(&self) };
visit_crate(*self.crate, (), mk_simple_visitor(@{
visit_item: |item| {
for item.attrs.each |attribute| {
unsafe {
(*this).match_and_collect_meta_item(local_def(item
.id),
attribute.node
.value);
}
}
2012-09-04 15:29:32 -05:00
},
.. *default_simple_visitor()
}));
}
fn collect_external_language_items() {
let crate_store = self.session.cstore;
do iter_crate_data(crate_store) |crate_number, _crate_metadata| {
for each_lang_item(crate_store, crate_number)
|node_id, item_index| {
let def_id = { crate: crate_number, node: node_id };
self.collect_item(item_index, def_id);
}
}
}
fn check_completeness() {
for self.item_refs.each |key, item_ref| {
match self.items.items[item_ref] {
2012-08-20 14:23:37 -05:00
None => {
2012-08-22 19:24:52 -05:00
self.session.err(fmt!("no item found for `%s`", key));
}
2012-08-20 14:23:37 -05:00
Some(_) => {
// OK.
}
}
}
}
fn collect() {
self.collect_local_language_items();
self.collect_external_language_items();
self.check_completeness();
}
}
fn collect_language_items(crate: @crate, session: Session) -> LanguageItems {
let mut items = LanguageItems::new();
let collector = LanguageItemCollector(crate, session, &mut items);
collector.collect();
copy items
}