// Copyright 2014 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 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. //! The AST pointer //! //! Provides `P`, a frozen owned smart pointer, as a replacement for `@T` in //! the AST. //! //! # Motivations and benefits //! //! * **Identity**: sharing AST nodes is problematic for the various analysis //! passes (e.g. one may be able to bypass the borrow checker with a shared //! `ExprAddrOf` node taking a mutable borrow). The only reason `@T` in the //! AST hasn't caused issues is because of inefficient folding passes which //! would always deduplicate any such shared nodes. Even if the AST were to //! switch to an arena, this would still hold, i.e. it couldn't use `&'a T`, //! but rather a wrapper like `P<'a, T>`. //! //! * **Immutability**: `P` disallows mutating its inner `T`, unlike `Box` //! (unless it contains an `Unsafe` interior, but that may be denied later). //! This mainly prevents mistakes, but can also enforces a kind of "purity". //! //! * **Efficiency**: folding can reuse allocation space for `P` and `Vec`, //! the latter even when the input and output types differ (as it would be the //! case with arenas or a GADT AST using type parameters to toggle features). //! //! * **Maintainability**: `P` provides a fixed interface - `Deref`, //! `and_then` and `map` - which can remain fully functional even if the //! implementation changes (using a special thread-local heap, for example). //! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated. //use std::fmt::{self, Display, Debug}; //use std::hash::{Hash, Hasher}; //use std::ops::Deref; use std::sync::Arc; pub type P = Arc; //pub struct P { // ptr: Arc //} #[allow(non_snake_case)] /// Construct a `P` from a `T` value. pub fn P(value: T) -> P { // P {ptr: Arc::new(value)} Arc::new(value) } //impl Deref for P { // type Target = T; // // fn deref<'a>(&'a self) -> &'a T { // &*self.ptr // } //} // //impl Clone for P { // fn clone(&self) -> P { // P {ptr: self.ptr.clone()} // } //} // //impl PartialEq for P { // fn eq(&self, other: &P) -> bool { // **self == **other // } //} // //impl Eq for P {} // //impl Debug for P { // fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Debug::fmt(&**self, f) // } //} //impl Display for P { // fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Display::fmt(&**self, f) // } //} // //impl fmt::Pointer for P { // fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // fmt::Pointer::fmt(&self.ptr, f) // } //} // //impl Hash for P { // fn hash(&self, state: &mut H) { // (**self).hash(state); // } //}