diff --git a/ast/src/ast.rs b/ast/src/ast.rs
index dc4acba89e..43b04ff44e 100644
--- a/ast/src/ast.rs
+++ b/ast/src/ast.rs
@@ -9,16 +9,16 @@ use num_bigint::BigInt;
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, PartialEq)]
-pub enum Top {
-    Program(Program),
-    Statement(Vec<Statement>),
-    Expression(Expression),
+pub enum Top<U = ()> {
+    Program(Program<U>),
+    Statement(Vec<Statement<U>>),
+    Expression(Expression<U>),
 }
 
 #[derive(Debug, PartialEq)]
 /// A full python program, it's a sequence of statements.
-pub struct Program {
-    pub statements: Suite,
+pub struct Program<U = ()> {
+    pub statements: Suite<U>,
 }
 
 #[derive(Debug, PartialEq)]
@@ -28,17 +28,18 @@ pub struct ImportSymbol {
 }
 
 #[derive(Debug, PartialEq)]
-pub struct Located<T> {
+pub struct Located<T, U = ()> {
     pub location: Location,
     pub node: T,
+    pub custom: U,
 }
 
-pub type Statement = Located<StatementType>;
-pub type Suite = Vec<Statement>;
+pub type Statement<U = ()> = Located<StatementType<U>, U>;
+pub type Suite<U = ()> = Vec<Statement<U>>;
 
 /// Abstract syntax tree nodes for python statements.
 #[derive(Debug, PartialEq)]
-pub enum StatementType {
+pub enum StatementType<U = ()> {
     /// A [`break`](https://docs.python.org/3/reference/simple_stmts.html#the-break-statement) statement.
     Break,
 
@@ -47,7 +48,7 @@ pub enum StatementType {
 
     /// A [`return`](https://docs.python.org/3/reference/simple_stmts.html#the-return-statement) statement.
     /// This is used to return from a function.
-    Return { value: Option<Expression> },
+    Return { value: Option<Expression<U>> },
 
     /// An [`import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement) statement.
     Import { names: Vec<ImportSymbol> },
@@ -64,35 +65,35 @@ pub enum StatementType {
 
     /// An [`assert`](https://docs.python.org/3/reference/simple_stmts.html#the-assert-statement) statement.
     Assert {
-        test: Expression,
-        msg: Option<Expression>,
+        test: Expression<U>,
+        msg: Option<Expression<U>>,
     },
 
     /// A `del` statement, to delete some variables.
-    Delete { targets: Vec<Expression> },
+    Delete { targets: Vec<Expression<U>> },
 
     /// Variable assignment. Note that we can assign to multiple targets.
     Assign {
-        targets: Vec<Expression>,
-        value: Expression,
+        targets: Vec<Expression<U>>,
+        value: Expression<U>,
     },
 
     /// Augmented assignment.
     AugAssign {
-        target: Box<Expression>,
+        target: Box<Expression<U>>,
         op: Operator,
-        value: Box<Expression>,
+        value: Box<Expression<U>>,
     },
 
     /// A type annotated assignment.
     AnnAssign {
-        target: Box<Expression>,
-        annotation: Box<Expression>,
-        value: Option<Expression>,
+        target: Box<Expression<U>>,
+        annotation: Box<Expression<U>>,
+        value: Option<Expression<U>>,
     },
 
     /// An expression used as a statement.
-    Expression { expression: Expression },
+    Expression { expression: Expression<U> },
 
     /// The [`global`](https://docs.python.org/3/reference/simple_stmts.html#the-global-statement) statement,
     /// to declare names as global variables.
@@ -104,56 +105,56 @@ pub enum StatementType {
 
     /// An [`if`](https://docs.python.org/3/reference/compound_stmts.html#the-if-statement) statement.
     If {
-        test: Expression,
-        body: Suite,
-        orelse: Option<Suite>,
+        test: Expression<U>,
+        body: Suite<U>,
+        orelse: Option<Suite<U>>,
     },
 
     /// A [`while`](https://docs.python.org/3/reference/compound_stmts.html#the-while-statement) statement.
     While {
-        test: Expression,
-        body: Suite,
-        orelse: Option<Suite>,
+        test: Expression<U>,
+        body: Suite<U>,
+        orelse: Option<Suite<U>>,
     },
 
     /// The [`with`](https://docs.python.org/3/reference/compound_stmts.html#the-with-statement) statement.
     With {
         is_async: bool,
-        items: Vec<WithItem>,
-        body: Suite,
+        items: Vec<WithItem<U>>,
+        body: Suite<U>,
     },
 
     /// A [`for`](https://docs.python.org/3/reference/compound_stmts.html#the-for-statement) statement.
     /// Contains the body of the loop, and the `else` clause.
     For {
         is_async: bool,
-        target: Box<Expression>,
-        iter: Box<Expression>,
-        body: Suite,
-        orelse: Option<Suite>,
+        target: Box<Expression<U>>,
+        iter: Box<Expression<U>>,
+        body: Suite<U>,
+        orelse: Option<Suite<U>>,
     },
 
     /// A `raise` statement.
     Raise {
-        exception: Option<Expression>,
-        cause: Option<Expression>,
+        exception: Option<Expression<U>>,
+        cause: Option<Expression<U>>,
     },
 
     /// A [`try`](https://docs.python.org/3/reference/compound_stmts.html#the-try-statement) statement.
     Try {
-        body: Suite,
-        handlers: Vec<ExceptHandler>,
-        orelse: Option<Suite>,
-        finalbody: Option<Suite>,
+        body: Suite<U>,
+        handlers: Vec<ExceptHandler<U>>,
+        orelse: Option<Suite<U>>,
+        finalbody: Option<Suite<U>>,
     },
 
     /// A [class definition](https://docs.python.org/3/reference/compound_stmts.html#class-definitions).
     ClassDef {
         name: String,
-        body: Suite,
-        bases: Vec<Expression>,
-        keywords: Vec<Keyword>,
-        decorator_list: Vec<Expression>,
+        body: Suite<U>,
+        bases: Vec<Expression<U>>,
+        keywords: Vec<Keyword<U>>,
+        decorator_list: Vec<Expression<U>>,
     },
 
     /// A [function definition](https://docs.python.org/3/reference/compound_stmts.html#function-definitions).
@@ -162,82 +163,82 @@ pub enum StatementType {
     FunctionDef {
         is_async: bool,
         name: String,
-        args: Box<Parameters>,
-        body: Suite,
-        decorator_list: Vec<Expression>,
-        returns: Option<Expression>,
+        args: Box<Parameters<U>>,
+        body: Suite<U>,
+        decorator_list: Vec<Expression<U>>,
+        returns: Option<Expression<U>>,
     },
 }
 
 #[derive(Debug, PartialEq)]
-pub struct WithItem {
-    pub context_expr: Expression,
-    pub optional_vars: Option<Expression>,
+pub struct WithItem<U = ()> {
+    pub context_expr: Expression<U>,
+    pub optional_vars: Option<Expression<U>>,
 }
 
 /// An expression at a given location in the sourcecode.
-pub type Expression = Located<ExpressionType>;
+pub type Expression<U = ()> = Located<ExpressionType<U>, U>;
 
 /// A certain type of expression.
 #[derive(Debug, PartialEq)]
-pub enum ExpressionType {
+pub enum ExpressionType<U = ()> {
     BoolOp {
         op: BooleanOperator,
-        values: Vec<Expression>,
+        values: Vec<Expression<U>>,
     },
 
     /// A binary operation on two operands.
     Binop {
-        a: Box<Expression>,
+        a: Box<Expression<U>>,
         op: Operator,
-        b: Box<Expression>,
+        b: Box<Expression<U>>,
     },
 
     /// Subscript operation.
     Subscript {
-        a: Box<Expression>,
-        b: Box<Expression>,
+        a: Box<Expression<U>>,
+        b: Box<Expression<U>>,
     },
 
     /// An unary operation.
     Unop {
         op: UnaryOperator,
-        a: Box<Expression>,
+        a: Box<Expression<U>>,
     },
 
     /// An await expression.
     Await {
-        value: Box<Expression>,
+        value: Box<Expression<U>>,
     },
 
     /// A yield expression.
     Yield {
-        value: Option<Box<Expression>>,
+        value: Option<Box<Expression<U>>>,
     },
 
     // A yield from expression.
     YieldFrom {
-        value: Box<Expression>,
+        value: Box<Expression<U>>,
     },
 
     /// A chained comparison. Note that in python you can use
     /// `1 < a < 10` for example.
     Compare {
-        vals: Vec<Expression>,
+        vals: Vec<Expression<U>>,
         ops: Vec<Comparison>,
     },
 
     /// Attribute access in the form of `value.name`.
     Attribute {
-        value: Box<Expression>,
+        value: Box<Expression<U>>,
         name: String,
     },
 
     /// A call expression.
     Call {
-        function: Box<Expression>,
-        args: Vec<Expression>,
-        keywords: Vec<Keyword>,
+        function: Box<Expression<U>>,
+        args: Vec<Expression<U>>,
+        keywords: Vec<Keyword<U>>,
     },
 
     /// A numeric literal.
@@ -247,43 +248,43 @@ pub enum ExpressionType {
 
     /// A `list` literal value.
     List {
-        elements: Vec<Expression>,
+        elements: Vec<Expression<U>>,
     },
 
     /// A `tuple` literal value.
     Tuple {
-        elements: Vec<Expression>,
+        elements: Vec<Expression<U>>,
     },
 
     /// A `dict` literal value.
     /// For example: `{2: 'two', 3: 'three'}`
     Dict {
-        elements: Vec<(Option<Expression>, Expression)>,
+        elements: Vec<(Option<Expression<U>>, Expression<U>)>,
     },
 
     /// A `set` literal.
     Set {
-        elements: Vec<Expression>,
+        elements: Vec<Expression<U>>,
     },
 
     Comprehension {
-        kind: Box<ComprehensionKind>,
-        generators: Vec<Comprehension>,
+        kind: Box<ComprehensionKind<U>>,
+        generators: Vec<Comprehension<U>>,
     },
 
     /// A starred expression.
     Starred {
-        value: Box<Expression>,
+        value: Box<Expression<U>>,
     },
 
     /// A slice expression.
     Slice {
-        elements: Vec<Expression>,
+        elements: Vec<Expression<U>>,
     },
 
     /// A string literal.
     String {
-        value: StringGroup,
+        value: StringGroup<U>,
     },
 
     /// A bytes literal.
@@ -298,21 +299,21 @@ pub enum ExpressionType {
 
     /// A `lambda` function expression.
     Lambda {
-        args: Box<Parameters>,
-        body: Box<Expression>,
+        args: Box<Parameters<U>>,
+        body: Box<Expression<U>>,
     },
 
     /// An if-expression.
     IfExpression {
-        test: Box<Expression>,
-        body: Box<Expression>,
-        orelse: Box<Expression>,
+        test: Box<Expression<U>>,
+        body: Box<Expression<U>>,
+        orelse: Box<Expression<U>>,
     },
 
     // A named expression
     NamedExpression {
-        left: Box<Expression>,
-        right: Box<Expression>,
+        left: Box<Expression<U>>,
+        right: Box<Expression<U>>,
     },
 
     /// The literal 'True'.
@@ -328,7 +329,7 @@ pub enum ExpressionType {
     Ellipsis,
 }
 
-impl Expression {
+impl<U> Expression<U> {
     /// Returns a short name for the node suitable for use in error messages.
     pub fn name(&self) -> &'static str {
         use self::ExpressionType::*;
@@ -380,61 +381,70 @@ impl Expression {
 /// In cpython this is called arguments, but we choose parameters to
 /// distinguish between function parameters and actual call arguments.
 #[derive(Debug, PartialEq, Default)]
-pub struct Parameters {
+pub struct Parameters<U = ()> {
     pub posonlyargs_count: usize,
-    pub args: Vec<Parameter>,
-    pub kwonlyargs: Vec<Parameter>,
-    pub vararg: Varargs, // Optionally we handle optionally named '*args' or '*'
-    pub kwarg: Varargs,
-    pub defaults: Vec<Expression>,
-    pub kw_defaults: Vec<Option<Expression>>,
+    pub args: Vec<Parameter<U>>,
+    pub kwonlyargs: Vec<Parameter<U>>,
+    pub vararg: Varargs<U>, // Optionally we handle optionally named '*args' or '*'
+    pub kwarg: Varargs<U>,
+    pub defaults: Vec<Expression<U>>,
+    pub kw_defaults: Vec<Option<Expression<U>>>,
 }
 
 /// A single formal parameter to a function.
 #[derive(Debug, PartialEq, Default)]
-pub struct Parameter {
+pub struct Parameter<U = ()> {
     pub location: Location,
     pub arg: String,
-    pub annotation: Option<Box<Expression>>,
+    pub annotation: Option<Box<Expression<U>>>,
 }
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, PartialEq)]
-pub enum ComprehensionKind {
-    GeneratorExpression { element: Expression },
-    List { element: Expression },
-    Set { element: Expression },
-    Dict { key: Expression, value: Expression },
+pub enum ComprehensionKind<U = ()> {
+    GeneratorExpression {
+        element: Expression<U>,
+    },
+    List {
+        element: Expression<U>,
+    },
+    Set {
+        element: Expression<U>,
+    },
+    Dict {
+        key: Expression<U>,
+        value: Expression<U>,
+    },
 }
 
 /// A list/set/dict/generator compression.
 #[derive(Debug, PartialEq)]
-pub struct Comprehension {
+pub struct Comprehension<U = ()> {
     pub location: Location,
-    pub target: Expression,
-    pub iter: Expression,
-    pub ifs: Vec<Expression>,
+    pub target: Expression<U>,
+    pub iter: Expression<U>,
+    pub ifs: Vec<Expression<U>>,
     pub is_async: bool,
 }
 
 #[derive(Debug, PartialEq)]
-pub struct ArgumentList {
-    pub args: Vec<Expression>,
-    pub keywords: Vec<Keyword>,
+pub struct ArgumentList<U = ()> {
+    pub args: Vec<Expression<U>>,
+    pub keywords: Vec<Keyword<U>>,
 }
 
 #[derive(Debug, PartialEq)]
-pub struct Keyword {
+pub struct Keyword<U = ()> {
     pub name: Option<String>,
-    pub value: Expression,
+    pub value: Expression<U>,
 }
 
 #[derive(Debug, PartialEq)]
-pub struct ExceptHandler {
+pub struct ExceptHandler<U = ()> {
     pub location: Location,
-    pub typ: Option<Expression>,
+    pub typ: Option<Expression<U>>,
     pub name: Option<String>,
-    pub body: Suite,
+    pub body: Suite<U>,
 }
 
 /// An operator for a binary operation (an operation with two operands).
@@ -506,35 +516,35 @@ pub enum ConversionFlag {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum StringGroup {
+pub enum StringGroup<U = ()> {
     Constant {
         value: String,
     },
     FormattedValue {
-        value: Box<Expression>,
+        value: Box<Expression<U>>,
         conversion: Option<ConversionFlag>,
-        spec: Option<Box<StringGroup>>,
+        spec: Option<Box<StringGroup<U>>>,
     },
     Joined {
-        values: Vec<StringGroup>,
+        values: Vec<StringGroup<U>>,
     },
 }
 
 #[derive(Debug, PartialEq)]
-pub enum Varargs {
+pub enum Varargs<U = ()> {
     None,
     Unnamed,
-    Named(Parameter),
+    Named(Parameter<U>),
 }
 
-impl Default for Varargs {
-    fn default() -> Varargs {
+impl<U> Default for Varargs<U> {
+    fn default() -> Varargs<U> {
         Varargs::None
     }
 }
 
-impl From<Option<Option<Parameter>>> for Varargs {
-    fn from(opt: Option<Option<Parameter>>) -> Varargs {
+impl<U> From<Option<Option<Parameter<U>>>> for Varargs<U> {
+    fn from(opt: Option<Option<Parameter<U>>>) -> Varargs<U> {
         match opt {
             Some(inner_opt) => match inner_opt {
                 Some(param) => Varargs::Named(param),
diff --git a/parser/src/fstring.rs b/parser/src/fstring.rs
index d71bcbb0cc..b67f9e462d 100644
--- a/parser/src/fstring.rs
+++ b/parser/src/fstring.rs
@@ -283,6 +283,7 @@ mod tests {
     fn mk_ident(name: &str, row: usize, col: usize) -> ast::Expression {
         ast::Expression {
             location: ast::Location::new(row, col),
+            custom: (),
             node: ast::ExpressionType::Identifier {
                 name: name.to_owned(),
             },
diff --git a/parser/src/parser.rs b/parser/src/parser.rs
index 4be140e779..a2659c4280 100644
--- a/parser/src/parser.rs
+++ b/parser/src/parser.rs
@@ -60,9 +60,11 @@ pub fn parse_statement(source: &str) -> Result<Vec<ast::Statement>, ParseError>
 ///
 /// assert_eq!(ast::Expression {
 ///         location: ast::Location::new(1, 3),
+///         custom: (),
 ///         node: ast::ExpressionType::Binop {
 ///             a: Box::new(ast::Expression {
 ///                 location: ast::Location::new(1, 1),
+///                 custom: (),
 ///                 node: ast::ExpressionType::Number {
 ///                     value: ast::Number::Integer { value: BigInt::from(1) }
 ///                 }
@@ -70,6 +72,7 @@ pub fn parse_statement(source: &str) -> Result<Vec<ast::Statement>, ParseError>
 ///             op: ast::Operator::Add,
 ///             b: Box::new(ast::Expression {
 ///                 location: ast::Location::new(1, 5),
+///                 custom: (),
 ///                 node: ast::ExpressionType::Number {
 ///                     value: ast::Number::Integer { value: BigInt::from(2) }
 ///                 }
@@ -108,6 +111,7 @@ mod tests {
     fn mk_ident(name: &str, row: usize, col: usize) -> ast::Expression {
         ast::Expression {
             location: ast::Location::new(row, col),
+            custom: (),
             node: ast::ExpressionType::Identifier {
                 name: name.to_owned(),
             },
@@ -117,6 +121,7 @@ mod tests {
     fn make_int(value: i32, row: usize, col: usize) -> ast::Expression {
         ast::Expression {
             location: ast::Location::new(row, col),
+            custom: (),
             node: ast::ExpressionType::Number {
                 value: ast::Number::Integer {
                     value: BigInt::from(value),
@@ -128,6 +133,7 @@ mod tests {
     fn make_string(value: &str, row: usize, col: usize) -> ast::Expression {
         ast::Expression {
             location: ast::Location::new(row, col),
+            custom: (),
             node: ast::ExpressionType::String {
                 value: ast::StringGroup::Constant {
                     value: String::from(value),
@@ -139,6 +145,7 @@ mod tests {
     fn as_statement(expr: ast::Expression) -> ast::Statement {
         ast::Statement {
             location: expr.location,
+            custom: (),
             node: ast::StatementType::Expression { expression: expr },
         }
     }
@@ -158,8 +165,10 @@ mod tests {
             ast::Program {
                 statements: vec![ast::Statement {
                     location: ast::Location::new(1, 1),
+                    custom: (),
                     node: ast::StatementType::Expression {
                         expression: ast::Expression {
+                            custom: (),
                             location: ast::Location::new(1, 6),
                             node: ast::ExpressionType::Call {
                                 function: Box::new(mk_ident("print", 1, 1)),
@@ -182,9 +191,11 @@ mod tests {
             ast::Program {
                 statements: vec![ast::Statement {
                     location: ast::Location::new(1, 1),
+                    custom: (),
                     node: ast::StatementType::Expression {
                         expression: ast::Expression {
                             location: ast::Location::new(1, 6),
+                            custom: (),
                             node: ast::ExpressionType::Call {
                                 function: Box::new(mk_ident("print", 1, 1)),
                                 args: vec![make_string("Hello world", 1, 8), make_int(2, 1, 22),],
@@ -206,9 +217,11 @@ mod tests {
             ast::Program {
                 statements: vec![ast::Statement {
                     location: ast::Location::new(1, 1),
+                    custom: (),
                     node: ast::StatementType::Expression {
                         expression: ast::Expression {
                             location: ast::Location::new(1, 8),
+                            custom: (),
                             node: ast::ExpressionType::Call {
                                 function: Box::new(mk_ident("my_func", 1, 1)),
                                 args: vec![make_string("positional", 1, 10)],
@@ -232,11 +245,13 @@ mod tests {
             parse_ast,
             vec![ast::Statement {
                 location: ast::Location::new(1, 1),
+                custom: (),
                 node: ast::StatementType::If {
                     test: make_int(1, 1, 4),
                     body: vec![as_statement(make_int(10, 1, 7))],
                     orelse: Some(vec![ast::Statement {
                         location: ast::Location::new(2, 1),
+                        custom: (),
                         node: ast::StatementType::If {
                             test: make_int(2, 2, 6),
                             body: vec![as_statement(make_int(20, 2, 9))],
@@ -256,6 +271,7 @@ mod tests {
             parse_ast,
             Ok(vec![as_statement(ast::Expression {
                 location: ast::Location::new(1, 1),
+                custom: (),
                 node: ast::ExpressionType::Lambda {
                     args: Box::new(ast::Parameters {
                         posonlyargs_count: 0,
@@ -279,6 +295,7 @@ mod tests {
                     }),
                     body: Box::new(ast::Expression {
                         location: ast::Location::new(1, 16),
+                        custom: (),
                         node: ast::ExpressionType::Binop {
                             a: Box::new(mk_ident("x", 1, 14)),
                             op: ast::Operator::Mult,
@@ -298,8 +315,10 @@ mod tests {
             parse_statement(&source),
             Ok(vec![ast::Statement {
                 location: ast::Location::new(1, 1),
+                custom: (),
                 node: ast::StatementType::Assign {
                     targets: vec![ast::Expression {
+                        custom: (),
                         location: ast::Location::new(1, 1),
                         node: ast::ExpressionType::Tuple {
                             elements: vec![mk_ident("a", 1, 1), mk_ident("b", 1, 4),]
@@ -307,6 +326,7 @@ mod tests {
                     }],
                     value: ast::Expression {
                         location: ast::Location::new(1, 8),
+                        custom: (),
                         node: ast::ExpressionType::Tuple {
                             elements: vec![make_int(4, 1, 8), make_int(5, 1, 11),]
                         }
@@ -325,6 +345,7 @@ mod tests {
             parse_statement(&source),
             Ok(vec![ast::Statement {
                 location: ast::Location::new(1, 1),
+                custom: (),
                 node: ast::StatementType::ClassDef {
                     name: String::from("Foo"),
                     bases: vec![mk_ident("A", 1, 11), mk_ident("B", 1, 14)],
@@ -332,6 +353,7 @@ mod tests {
                     body: vec![
                         ast::Statement {
                             location: ast::Location::new(2, 2),
+                            custom: (),
                             node: ast::StatementType::FunctionDef {
                                 is_async: false,
                                 name: String::from("__init__"),
@@ -350,6 +372,7 @@ mod tests {
                                 }),
                                 body: vec![ast::Statement {
                                     location: ast::Location::new(3, 3),
+                                    custom: (),
                                     node: ast::StatementType::Pass,
                                 }],
                                 decorator_list: vec![],
@@ -358,6 +381,7 @@ mod tests {
                         },
                         ast::Statement {
                             location: ast::Location::new(4, 2),
+                            custom: (),
                             node: ast::StatementType::FunctionDef {
                                 is_async: false,
                                 name: String::from("method_with_default"),
@@ -383,6 +407,7 @@ mod tests {
                                 }),
                                 body: vec![ast::Statement {
                                     location: ast::Location::new(5, 3),
+                                    custom: (),
                                     node: ast::StatementType::Pass,
                                 }],
                                 decorator_list: vec![],
@@ -404,6 +429,7 @@ mod tests {
             parse_ast,
             ast::Expression {
                 location: ast::Location::new(1, 1),
+                custom: (),
                 node: ast::ExpressionType::Comprehension {
                     kind: Box::new(ast::ComprehensionKind::Dict {
                         key: mk_ident("x1", 1, 2),
@@ -428,6 +454,7 @@ mod tests {
         assert_eq!(
             parse_ast,
             ast::Expression {
+                custom: (),
                 location: ast::Location::new(1, 1),
                 node: ast::ExpressionType::Comprehension {
                     kind: Box::new(ast::ComprehensionKind::List {
@@ -452,6 +479,7 @@ mod tests {
         assert_eq!(
             parse_ast,
             ast::Expression {
+                custom: (),
                 location: ast::Location::new(1, 1),
                 node: ast::ExpressionType::Comprehension {
                     kind: Box::new(ast::ComprehensionKind::List {
@@ -461,6 +489,7 @@ mod tests {
                         ast::Comprehension {
                             location: ast::Location::new(1, 4),
                             target: ast::Expression {
+                                custom: (),
                                 location: ast::Location::new(1, 8),
                                 node: ast::ExpressionType::Tuple {
                                     elements: vec![mk_ident("y", 1, 8), mk_ident("y2", 1, 11),],
@@ -476,6 +505,7 @@ mod tests {
                             iter: mk_ident("b", 1, 28),
                             ifs: vec![
                                 ast::Expression {
+                                    custom: (),
                                     location: ast::Location::new(1, 35),
                                     node: ast::ExpressionType::Compare {
                                         vals: vec![mk_ident("a", 1, 33), make_int(5, 1, 37),],
@@ -483,6 +513,7 @@ mod tests {
                                     }
                                 },
                                 ast::Expression {
+                                    custom: (),
                                     location: ast::Location::new(1, 44),
                                     node: ast::ExpressionType::Compare {
                                         vals: vec![mk_ident("a", 1, 42), make_int(10, 1, 46),],
diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
index e9b9aaaeaf..4fdfdc2f32 100644
--- a/parser/src/python.lalrpop
+++ b/parser/src/python.lalrpop
@@ -69,6 +69,7 @@ PassStatement: ast::Statement = {
     <location:@L> "pass" => {
         ast::Statement {
             location,
+            custom: (),
             node: ast::StatementType::Pass,
         }
     },
@@ -78,6 +79,7 @@ DelStatement: ast::Statement = {
     <location:@L> "del" <targets:ExpressionList2> => {
         ast::Statement {
             location,
+            custom: (),
             node: ast::StatementType::Delete { targets },
         }
     },
@@ -88,6 +90,7 @@ ExpressionStatement: ast::Statement = {
         // Just an expression, no assignment:
         if suffix.is_empty() {
             ast::Statement {
+                custom: (),
                 location,
                 node: ast::StatementType::Expression { expression }
             }
@@ -102,6 +105,7 @@ ExpressionStatement: ast::Statement = {
             let value = values.into_iter().next().unwrap();
 
             ast::Statement {
+                custom: (),
                 location,
                 node: ast::StatementType::Assign { targets, value },
             }
@@ -109,6 +113,7 @@ ExpressionStatement: ast::Statement = {
     },
     <location:@L> <target:TestOrStarExprList> <op:AugAssign> <rhs:TestListOrYieldExpr> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::AugAssign {
                 target: Box::new(target),
@@ -119,6 +124,7 @@ ExpressionStatement: ast::Statement = {
     },
     <location:@L> <target:Test> ":" <annotation:Test> <rhs:AssignSuffix?> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::AnnAssign {
                 target: Box::new(target),
@@ -145,6 +151,7 @@ TestOrStarExprList: ast::Expression = {
         } else {
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Tuple { elements }
             }
         }
@@ -158,6 +165,7 @@ TestOrStarNamedExprList: ast::Expression = {
         } else {
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Tuple { elements }
             }
         }
@@ -193,24 +201,28 @@ AugAssign: ast::Operator = {
 FlowStatement: ast::Statement = {
     <location:@L> "break" => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Break,
         }
     },
     <location:@L> "continue" => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Continue,
         }
     },
     <location:@L> "return" <value:TestList?> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Return { value },
         }
     },
     <location:@L> <expression:YieldExpr> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Expression { expression },
         }
@@ -221,12 +233,14 @@ FlowStatement: ast::Statement = {
 RaiseStatement: ast::Statement = {
     <location:@L> "raise" => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Raise { exception: None, cause: None },
         }
     },
     <location:@L> "raise" <t:Test> <c:("from" Test)?> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Raise { exception: Some(t), cause: c.map(|x| x.1) },
         }
@@ -236,6 +250,7 @@ RaiseStatement: ast::Statement = {
 ImportStatement: ast::Statement = {
     <location:@L> "import" <names: OneOrMore<ImportAsAlias<DottedName>>> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Import { names },
         }
@@ -243,6 +258,7 @@ ImportStatement: ast::Statement = {
     <location:@L> "from" <source:ImportFromLocation> "import" <names: ImportAsNames> => {
         let (level, module) = source;
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::ImportFrom {
                 level,
@@ -298,6 +314,7 @@ DottedName: String = {
 GlobalStatement: ast::Statement = {
     <location:@L> "global" <names:OneOrMore<Identifier>> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Global { names }
         }
@@ -307,6 +324,7 @@ GlobalStatement: ast::Statement = {
 NonlocalStatement: ast::Statement = {
     <location:@L> "nonlocal" <names:OneOrMore<Identifier>> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Nonlocal { names }
         }
@@ -316,6 +334,7 @@ NonlocalStatement: ast::Statement = {
 AssertStatement: ast::Statement = {
     <location:@L> "assert" <test:Test> <msg: ("," Test)?> => {
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Assert {
                 test, msg: msg.map(|e| e.1)
@@ -342,6 +361,7 @@ IfStatement: ast::Statement = {
         // handle elif:
         for i in s2.into_iter().rev() {
             let x = ast::Statement {
+                custom: (),
                 location: i.0,
                 node: ast::StatementType::If { test: i.2, body: i.4, orelse: last },
             };
@@ -349,6 +369,7 @@ IfStatement: ast::Statement = {
         }
 
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::If { test, body, orelse: last }
         }
@@ -359,6 +380,7 @@ WhileStatement: ast::Statement = {
     <location:@L> "while" <test:NamedExpressionTest> ":" <body:Suite> <s2:("else" ":" Suite)?> => {
         let orelse = s2.map(|s| s.2);
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::While {
                 test,
@@ -374,6 +396,7 @@ ForStatement: ast::Statement = {
         let is_async = is_async.is_some();
         let orelse = s2.map(|s| s.2);
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::For {
                 is_async,
@@ -391,6 +414,7 @@ TryStatement: ast::Statement = {
         let orelse = else_suite.map(|s| s.2);
         let finalbody = finally.map(|s| s.2);
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Try {
                 body,
@@ -405,6 +429,7 @@ TryStatement: ast::Statement = {
         let orelse = None;
         let finalbody = Some(finally.2);
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::Try {
                 body,
@@ -439,6 +464,7 @@ WithStatement: ast::Statement = {
     <location:@L> <is_async:"async"?> "with" <items:OneOrMore<WithItem>> ":" <body:Suite> => {
         let is_async = is_async.is_some();
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::With { is_async, items, body },
         }
@@ -456,6 +482,7 @@ FuncDef: ast::Statement = {
     <decorator_list:Decorator*> <location:@L> <is_async:"async"?> "def" <name:Identifier> <args:Parameters> <r:("->" Test)?> ":" <body:Suite> => {
         let is_async = is_async.is_some();
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::FunctionDef {
                 is_async,
@@ -597,6 +624,7 @@ ClassDef: ast::Statement = {
             None => (vec![], vec![]),
         };
         ast::Statement {
+            custom: (),
             location,
             node: ast::StatementType::ClassDef {
                 name,
@@ -612,11 +640,13 @@ ClassDef: ast::Statement = {
 Path: ast::Expression = {
     <location:@L> <n:Identifier> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Identifier { name: n }
     },
     <p:Path> <location:@L> "." <n:name> => {
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Attribute {
                 value: Box::new(p),
                 name: n,
@@ -635,10 +665,12 @@ Decorator: ast::Expression = {
 YieldExpr: ast::Expression = {
     <location:@L> "yield" <value:TestList?> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Yield { value: value.map(Box::new) }
     },
     <location:@L> "yield" "from" <e:Test> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::YieldFrom { value: Box::new(e) }
     },
 };
@@ -648,6 +680,7 @@ Test: ast::Expression = {
         if let Some(c) = condition {
             ast::Expression {
                 location: c.0,
+                custom: (),
                 node: ast::ExpressionType::IfExpression {
                     test: Box::new(c.2),
                     body: Box::new(expr),
@@ -666,10 +699,12 @@ NamedExpressionTest: ast::Expression = {
         if let Some(l) = left {
             ast::Expression {
                 location: location,
+                custom: (),
                 node: ast::ExpressionType::NamedExpression {
                         left: Box::new(
                             ast::Expression {
                                 location: location,
+                                custom: (),
                                 node: ast::ExpressionType::Identifier { name: l.0, },
                             }),
                         right: Box::new(right),
@@ -685,6 +720,7 @@ LambdaDef: ast::Expression = {
     <location:@L> "lambda" <p:ParameterList<UntypedParameter>?> ":" <body:Test> =>
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Lambda {
                 args: Box::new(p.unwrap_or_default()),
                 body: Box::new(body)
@@ -701,6 +737,7 @@ OrTest: ast::Expression = {
             values.extend(e2.into_iter().map(|e| e.1));
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::BoolOp { op: ast::BooleanOperator::Or, values }
             }
         }
@@ -716,6 +753,7 @@ AndTest: ast::Expression = {
             values.extend(e2.into_iter().map(|e| e.1));
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::BoolOp { op: ast::BooleanOperator::And, values }
             }
         }
@@ -725,6 +763,7 @@ AndTest: ast::Expression = {
 NotTest: ast::Expression = {
     <location:@L> "not" <e:NotTest> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Unop { a: Box::new(e), op: ast::UnaryOperator::Not }
     },
     Comparison,
@@ -740,6 +779,7 @@ Comparison: ast::Expression = {
         }
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Compare { vals, ops }
         }
     },
@@ -762,6 +802,7 @@ CompOp: ast::Comparison = {
 Expression: ast::Expression = {
     <e1:Expression> <location:@L> "|" <e2:XorExpression> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Binop { a: Box::new(e1), op: ast::Operator::BitOr, b: Box::new(e2) }
     },
     XorExpression,
@@ -770,6 +811,7 @@ Expression: ast::Expression = {
 XorExpression: ast::Expression = {
     <e1:XorExpression> <location:@L> "^" <e2:AndExpression> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Binop { a: Box::new(e1), op: ast::Operator::BitXor, b: Box::new(e2) }
     },
     AndExpression,
@@ -778,6 +820,7 @@ XorExpression: ast::Expression = {
 AndExpression: ast::Expression = {
     <e1:AndExpression> <location:@L> "&" <e2:ShiftExpression> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Binop { a: Box::new(e1), op: ast::Operator::BitAnd, b: Box::new(e2) }
     },
     ShiftExpression,
@@ -786,6 +829,7 @@ AndExpression: ast::Expression = {
 ShiftExpression: ast::Expression = {
     <e1:ShiftExpression> <location:@L> <op:ShiftOp> <e2:ArithmaticExpression> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Binop { a: Box::new(e1), op, b: Box::new(e2) }
     },
     ArithmaticExpression,
@@ -799,6 +843,7 @@ ShiftOp: ast::Operator = {
 ArithmaticExpression: ast::Expression = {
     <a:ArithmaticExpression> <location:@L> <op:AddOp> <b:Term> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Binop { a: Box::new(a), op, b: Box::new(b) }
     },
     Term,
@@ -812,6 +857,7 @@ AddOp: ast::Operator = {
 Term: ast::Expression = {
     <a:Term> <location:@L> <op:MulOp> <b:Factor> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Binop { a: Box::new(a), op, b: Box::new(b) }
     },
     Factor,
@@ -828,6 +874,7 @@ MulOp: ast::Operator = {
 Factor: ast::Expression = {
     <location:@L> <op:UnOp> <e:Factor> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Unop { a: Box::new(e), op }
     },
     Power,
@@ -845,6 +892,7 @@ Power: ast::Expression = {
             None => e,
             Some((location, _, b)) => ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Binop { a: Box::new(e), op: ast::Operator::Pow, b: Box::new(b) }
             },
         }
@@ -856,6 +904,7 @@ AtomExpr: ast::Expression = {
         if is_await.is_some() {
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Await { value: Box::new(atom) }
             }
         } else {
@@ -869,15 +918,18 @@ AtomExpr2: ast::Expression = {
     <f:AtomExpr2> <location:@L> "(" <a:ArgumentList> ")" => {
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Call { function: Box::new(f), args: a.args, keywords: a.keywords }
         }
     },
     <e:AtomExpr2> <location:@L> "[" <s:SubscriptList> "]" => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Subscript { a: Box::new(e), b: Box::new(s) }
     },
     <e:AtomExpr2> <location:@L> "." <name:Identifier> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Attribute { value: Box::new(e), name }
     },
 };
@@ -894,6 +946,7 @@ SubscriptList: ast::Expression = {
 
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Tuple { elements: dims },
             }
         }
@@ -903,47 +956,54 @@ SubscriptList: ast::Expression = {
 Subscript: ast::Expression = {
     Test,
     <e1:Test?> <location:@L> ":" <e2:Test?> <e3:SliceOp?>  => {
-        let s1 = e1.unwrap_or(ast::Expression { location, node: ast::ExpressionType::None });
-        let s2 = e2.unwrap_or(ast::Expression { location, node: ast::ExpressionType::None });
-        let s3 = e3.unwrap_or(ast::Expression { location, node: ast::ExpressionType::None });
+        let s1 = e1.unwrap_or(ast::Expression { location, custom: (), node: ast::ExpressionType::None });
+        let s2 = e2.unwrap_or(ast::Expression { location, custom: (), node: ast::ExpressionType::None });
+        let s3 = e3.unwrap_or(ast::Expression { location, custom: (), node: ast::ExpressionType::None });
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Slice { elements: vec![s1, s2, s3] }
         }
     }
 };
 
 SliceOp: ast::Expression = {
-    <location:@L> ":" <e:Test?> => e.unwrap_or(ast::Expression {location, node: ast::ExpressionType::None})
+    <location:@L> ":" <e:Test?> => e.unwrap_or(ast::Expression {location, custom: (), node: ast::ExpressionType::None})
 }
 
 Atom: ast::Expression = {
     <location:@L> <value:StringGroup> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::String { value }
     },
     <location:@L> <value:Bytes> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Bytes { value }
     },
     <location:@L> <value:Number> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Number { value }
     },
     <location:@L> <name:Identifier> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Identifier { name }
     },
     <location:@L> "[" <e:ListLiteralValues?> "]" => {
         let elements = e.unwrap_or_default();
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::List { elements }
         }
     },
     <location:@L> "[" <element:TestOrStarNamedExpr> <generators:CompFor> "]" => {
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Comprehension {
                 kind: Box::new(ast::ComprehensionKind::List { element }),
                 generators,
@@ -953,6 +1013,7 @@ Atom: ast::Expression = {
     <location:@L> "(" <elements:TestOrStarNamedExprList?> ")" => {
         elements.unwrap_or(ast::Expression {
              location,
+             custom: (),
              node: ast::ExpressionType::Tuple { elements: Vec::new() }
         })
     },
@@ -960,6 +1021,7 @@ Atom: ast::Expression = {
     <location:@L> "(" <element:Test> <generators:CompFor> ")" => {
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Comprehension {
                 kind: Box::new(ast::ComprehensionKind::GeneratorExpression { element }),
                 generators,
@@ -968,11 +1030,13 @@ Atom: ast::Expression = {
     },
     <location:@L> "{" <e:DictLiteralValues?> "}" => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Dict { elements: e.unwrap_or_default() }
     },
     <location:@L> "{" <e1:DictEntry> <generators:CompFor> "}" => {
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Comprehension {
                 kind: Box::new(ast::ComprehensionKind::Dict { key: e1.0, value: e1.1 }),
                 generators,
@@ -981,21 +1045,23 @@ Atom: ast::Expression = {
     },
     <location:@L> "{" <elements:SetLiteralValues> "}" => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Set { elements }
     },
     <location:@L> "{" <element:Test> <generators:CompFor> "}" => {
         ast::Expression {
             location,
+            custom: (),
             node: ast::ExpressionType::Comprehension {
                 kind: Box::new(ast::ComprehensionKind::Set { element }),
                 generators,
             }
         }
     },
-    <location:@L> "True" => ast::Expression { location, node: ast::ExpressionType::True },
-    <location:@L> "False" => ast::Expression { location, node: ast::ExpressionType::False },
-    <location:@L> "None" => ast::Expression { location, node: ast::ExpressionType::None },
-    <location:@L> "..." => ast::Expression { location, node: ast::ExpressionType::Ellipsis },
+    <location:@L> "True" => ast::Expression { location, custom: (), node: ast::ExpressionType::True },
+    <location:@L> "False" => ast::Expression { location, custom: (), node: ast::ExpressionType::False },
+    <location:@L> "None" => ast::Expression { location, custom: (), node: ast::ExpressionType::None },
+    <location:@L> "..." => ast::Expression { location, custom: (), node: ast::ExpressionType::Ellipsis },
 };
 
 ListLiteralValues: Vec<ast::Expression> = {
@@ -1031,6 +1097,7 @@ ExpressionList: ast::Expression = {
         } else {
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Tuple { elements },
             }
         }
@@ -1052,6 +1119,7 @@ TestList: ast::Expression = {
         } else {
             ast::Expression {
                 location,
+                custom: (),
                 node: ast::ExpressionType::Tuple { elements },
             }
         }
@@ -1062,6 +1130,7 @@ TestList: ast::Expression = {
 StarExpr: ast::Expression = {
     <location:@L> "*" <e:Expression> => ast::Expression {
         location,
+        custom: (),
         node: ast::ExpressionType::Starred { value: Box::new(e) },
     }
 };
@@ -1091,6 +1160,7 @@ FunctionArgument: (Option<Option<String>>, ast::Expression) = {
         let expr = match c {
             Some(c) => ast::Expression {
                 location: e.location,
+                custom: (),
                 node: ast::ExpressionType::Comprehension {
                     kind: Box::new(ast::ComprehensionKind::GeneratorExpression { element: e }),
                     generators: c,
@@ -1101,7 +1171,7 @@ FunctionArgument: (Option<Option<String>>, ast::Expression) = {
         (None, expr)
     },
     <i:Identifier> "=" <e:Test> => (Some(Some(i)), e),
-    <location:@L> "*" <e:Test> => (None, ast::Expression { location, node: ast::ExpressionType::Starred { value: Box::new(e) } }),
+    <location:@L> "*" <e:Test> => (None, ast::Expression { location, custom: (), node: ast::ExpressionType::Starred { value: Box::new(e) } }),
     "**" <e:Test> => (Some(None), e),
 };