diff --git a/Cargo.lock b/Cargo.lock
index 4a9c122916..541f03ac7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -286,6 +286,7 @@ dependencies = [
  "serde_cbor 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "strum 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "strum_macros 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
diff --git a/c2rust-ast-exporter/src/AstExporter.cpp b/c2rust-ast-exporter/src/AstExporter.cpp
index e31857f6b7..d29b22a8be 100644
--- a/c2rust-ast-exporter/src/AstExporter.cpp
+++ b/c2rust-ast-exporter/src/AstExporter.cpp
@@ -472,9 +472,9 @@ class TranslateASTVisitor final
     }
 
     // Template required because Decl and Stmt don't share a common base class
-    void encode_entry_raw(void *ast, ASTEntryTag tag, SourceLocation loc,
-                          const QualType ty, bool rvalue, bool isVaList,
-                          bool encodeMacroExpansions,
+    void encode_entry_raw(void *ast, ASTEntryTag tag, SourceRange loc,
+                          const QualType ty, bool rvalue,
+                          bool isVaList, bool encodeMacroExpansions,
                           const std::vector<void *> &childIds,
                           std::function<void(CborEncoder *)> extra) {
         if (!markForExport(ast, tag))
@@ -501,17 +501,19 @@ class TranslateASTVisitor final
         cbor_encoder_close_container(&local, &childEnc);
 
         // 3 - File number
-        // 4 - Line number
-        // 5 - Column number
-        encodeSourcePos(&local, loc, isVaList);
+        // 4 - Begin Line number
+        // 5 - Begin Column number
+        // 6 - End Line number
+        // 7 - End Column number
+        encodeSourceSpan(&local, loc, isVaList);
 
-        // 6 - Type ID (only for expressions)
+        // 8 - Type ID (only for expressions)
         encode_qualtype(&local, ty);
 
-        // 7 - Is Rvalue (only for expressions)
+        // 9 - Is Rvalue (only for expressions)
         cbor_encode_boolean(&local, rvalue);
 
-        // 8 - Macro expansion stack, starting with initial macro call and ending
+        // 10 - Macro expansion stack, starting with initial macro call and ending
         // with the innermost replacement.
         cbor_encoder_create_array(&local, &childEnc,
                                   encodeMacroExpansions ? curMacroExpansionStack.size() : 0);
@@ -523,7 +525,7 @@ class TranslateASTVisitor final
         }
         cbor_encoder_close_container(&local, &childEnc);
 
-        // 9.. - Extra entries
+        // 11.. - Extra entries
         extra(&local);
 
         cbor_encoder_close_container(encoder, &local);
@@ -543,13 +545,8 @@ class TranslateASTVisitor final
         auto ty = ast->getType();
         auto isVaList = false;
         auto encodeMacroExpansions = true;
-#if CLANG_VERSION_MAJOR < 8
-        SourceLocation loc = ast->getLocStart();
-#else
-        SourceLocation loc = ast->getBeginLoc();
-#endif // CLANG_VERSION_MAJOR
-        encode_entry_raw(ast, tag, loc, ty, ast->isRValue(), isVaList, encodeMacroExpansions,
-                         childIds, extra);
+        encode_entry_raw(ast, tag, ast->getSourceRange(), ty, ast->isRValue(), isVaList,
+                         encodeMacroExpansions, childIds, extra);
         typeEncoder.VisitQualType(ty);
     }
 
@@ -560,13 +557,8 @@ class TranslateASTVisitor final
         auto rvalue = false;
         auto isVaList = false;
         auto encodeMacroExpansions = false;
-#if CLANG_VERSION_MAJOR < 8
-        SourceLocation loc = ast->getLocStart();
-#else
-        SourceLocation loc = ast->getBeginLoc();
-#endif // CLANG_VERSION_MAJOR
-        encode_entry_raw(ast, tag, loc, s, rvalue, isVaList, encodeMacroExpansions,
-                         childIds, extra);
+        encode_entry_raw(ast, tag, ast->getSourceRange(), s, rvalue, isVaList,
+                         encodeMacroExpansions, childIds, extra);
     }
 
     void encode_entry(
@@ -575,7 +567,7 @@ class TranslateASTVisitor final
         std::function<void(CborEncoder *)> extra = [](CborEncoder *) {}) {
         auto rvalue = false;
         auto encodeMacroExpansions = false;
-        encode_entry_raw(ast, tag, ast->getLocation(), T, rvalue,
+        encode_entry_raw(ast, tag, ast->getSourceRange(), T, rvalue,
                          isVaList(ast, T), encodeMacroExpansions, childIds, extra);
     }
 
@@ -583,7 +575,7 @@ class TranslateASTVisitor final
     /// definition location is not the same as the canonical declaration
     /// location.
     void encode_entry(
-        Decl *ast, ASTEntryTag tag, SourceLocation loc,
+        Decl *ast, ASTEntryTag tag, SourceRange loc,
         const std::vector<void *> &childIds, const QualType T,
         std::function<void(CborEncoder *)> extra = [](CborEncoder *) {}) {
         auto rvalue = false;
@@ -714,7 +706,8 @@ class TranslateASTVisitor final
             std::vector<void *> childIds(Info.Expressions.begin(),
                                          Info.Expressions.end());
 
-            encode_entry_raw(Mac, tag, Mac->getDefinitionLoc(), QualType(), false,
+            auto range = SourceRange(Mac->getDefinitionLoc(), Mac->getDefinitionEndLoc());
+            encode_entry_raw(Mac, tag, range, QualType(), false,
                              false, false, childIds, [Name](CborEncoder *local) {
                                  cbor_encode_string(local, Name.str());
                              });
@@ -731,15 +724,41 @@ class TranslateASTVisitor final
             manager.isMacroBodyExpansion(loc))
             loc = manager.getFileLoc(loc);
 
+        auto fileid = getExporterFileId(manager.getFileID(loc), isVaList);
         auto line = manager.getPresumedLineNumber(loc);
         auto col = manager.getPresumedColumnNumber(loc);
-        auto fileid = getExporterFileId(manager.getFileID(loc), isVaList);
 
         cbor_encode_uint(enc, fileid);
         cbor_encode_uint(enc, line);
         cbor_encode_uint(enc, col);
     }
 
+    void encodeSourceSpan(CborEncoder *enc, SourceRange loc, bool isVaList = false) {
+        auto &manager = Context->getSourceManager();
+
+        auto begin = loc.getBegin();
+        auto end = loc.getEnd();
+        // A check to see if the Source Location is a Macro
+        if (manager.isMacroArgExpansion(begin) ||
+            manager.isMacroBodyExpansion(begin))
+            begin = manager.getFileLoc(begin);
+        if (manager.isMacroArgExpansion(end) ||
+            manager.isMacroBodyExpansion(end))
+            end = manager.getFileLoc(end);
+
+        auto fileid = getExporterFileId(manager.getFileID(begin), isVaList);
+        auto begin_line = manager.getPresumedLineNumber(begin);
+        auto begin_col = manager.getPresumedColumnNumber(begin);
+        auto end_line = manager.getPresumedLineNumber(end);
+        auto end_col = manager.getPresumedColumnNumber(end);
+
+        cbor_encode_uint(enc, fileid);
+        cbor_encode_uint(enc, begin_line);
+        cbor_encode_uint(enc, begin_col);
+        cbor_encode_uint(enc, end_line);
+        cbor_encode_uint(enc, end_col);
+    }
+
     uint64_t getExporterFileId(FileID id, bool isVaList) {
         if (id.isInvalid())
             return 0;
@@ -1572,10 +1591,10 @@ class TranslateASTVisitor final
         if (!FD->isCanonicalDecl()) {
             // Emit non-canonical decl so we have a placeholder to attach comments to
             std::vector<void *> childIds = {FD->getCanonicalDecl()};
-            auto loc = FD->getLocation();
+            auto span = FD->getSourceRange();
             if (FD->doesThisDeclarationHaveABody())
-                loc = FD->getCanonicalDecl()->getLocation();
-            encode_entry(FD, TagNonCanonicalDecl, loc, childIds, FD->getType());
+                span = FD->getCanonicalDecl()->getSourceRange();
+            encode_entry(FD, TagNonCanonicalDecl, span, childIds, FD->getType());
             return true;
         }
 
@@ -1600,8 +1619,9 @@ class TranslateASTVisitor final
         childIds.push_back(body);
 
         auto functionType = FD->getType();
+        auto span = paramsFD->getSourceRange();
         encode_entry(
-            FD, TagFunctionDecl, paramsFD->getLocation(), childIds, functionType,
+            FD, TagFunctionDecl, span, childIds, functionType,
             [this, FD](CborEncoder *array) {
                 auto name = FD->getNameAsString();
                 cbor_encode_string(array, name);
diff --git a/c2rust-ast-exporter/src/clang_ast.rs b/c2rust-ast-exporter/src/clang_ast.rs
index 8f3eb42759..056a1eb4bf 100644
--- a/c2rust-ast-exporter/src/clang_ast.rs
+++ b/c2rust-ast-exporter/src/clang_ast.rs
@@ -22,18 +22,56 @@ impl LRValue {
     }
 }
 
-#[derive(Debug, Clone, PartialOrd, PartialEq, Ord, Eq)]
+#[derive(Copy, Debug, Clone, PartialOrd, PartialEq, Ord, Eq)]
 pub struct SrcLoc {
     pub fileid: u64,
     pub line: u64,
     pub column: u64,
 }
 
+#[derive(Copy, Debug, Clone, PartialOrd, PartialEq, Ord, Eq)]
+pub struct SrcSpan {
+    pub fileid: u64,
+    pub begin_line: u64,
+    pub begin_column: u64,
+    pub end_line: u64,
+    pub end_column: u64,
+}
+
+impl From<SrcLoc> for SrcSpan {
+    fn from(loc: SrcLoc) -> Self {
+        Self {
+            fileid: loc.fileid,
+            begin_line: loc.line,
+            begin_column: loc.column,
+            end_line: loc.line,
+            end_column: loc.column,
+        }
+    }
+}
+
+impl SrcSpan {
+    pub fn begin(&self) -> SrcLoc {
+        SrcLoc {
+            fileid: self.fileid,
+            line: self.begin_line,
+            column: self.begin_column,
+        }
+    }
+    pub fn end(&self) -> SrcLoc {
+        SrcLoc {
+            fileid: self.fileid,
+            line: self.end_line,
+            column: self.end_column,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct AstNode {
     pub tag: ASTEntryTag,
     pub children: Vec<Option<u64>>,
-    pub loc: SrcLoc,
+    pub loc: SrcSpan,
     pub type_id: Option<u64>,
     pub rvalue: LRValue,
 
@@ -152,10 +190,10 @@ pub fn process(items: Value) -> error::Result<AstContext> {
                 .map(|x| expect_opt_u64(x).unwrap())
                 .collect::<Vec<Option<u64>>>();
 
-            let type_id: Option<u64> = expect_opt_u64(&entry[6]).unwrap();
+            let type_id: Option<u64> = expect_opt_u64(&entry[8]).unwrap();
             let fileid = entry[3].as_u64().unwrap();
 
-            let macro_expansions = entry[8]
+            let macro_expansions = entry[10]
                 .as_array()
                 .unwrap()
                 .iter()
@@ -165,19 +203,21 @@ pub fn process(items: Value) -> error::Result<AstContext> {
             let node = AstNode {
                 tag: import_ast_tag(tag),
                 children,
-                loc: SrcLoc {
+                loc: SrcSpan {
                     fileid,
-                    line: entry[4].as_u64().unwrap(),
-                    column: entry[5].as_u64().unwrap(),
+                    begin_line: entry[4].as_u64().unwrap(),
+                    begin_column: entry[5].as_u64().unwrap(),
+                    end_line: entry[6].as_u64().unwrap(),
+                    end_column: entry[7].as_u64().unwrap(),
                 },
                 type_id,
-                rvalue: if entry[7].as_boolean().unwrap() {
+                rvalue: if entry[9].as_boolean().unwrap() {
                     LRValue::RValue
                 } else {
                     LRValue::LValue
                 },
                 macro_expansions,
-                extras: entry[9..].to_vec(),
+                extras: entry[11..].to_vec(),
             };
 
             asts.insert(entry_id, node);
diff --git a/c2rust-refactor/src/rewrite/base.rs b/c2rust-refactor/src/rewrite/base.rs
index a4027cc764..7ae363b3bc 100644
--- a/c2rust-refactor/src/rewrite/base.rs
+++ b/c2rust-refactor/src/rewrite/base.rs
@@ -220,7 +220,7 @@ where
             diff::Result::Left(_) => {
                 // There's an item on the left corresponding to nothing on the right.
                 // Delete the item from the left.
-                let old_span = rewind_span_over_whitespace(ast(&old[i]).splice_span(), &rcx);
+                let old_span = ast(&old[i]).splice_span();
                 // let old_span = ast(&old[i]).splice_span();
                 let old_span = match old_ids[i] {
                     SeqItemId::Node(id) => extend_span_comments(&id, old_span, &rcx),
@@ -482,7 +482,7 @@ pub fn extend_span_comments(id: &NodeId, span: Span, rcx: &RewriteCtxt) -> Span
 
 /// Extend a node span to cover comments around it.  Returns Ok(span) if all
 /// comments were covered, and Err(span) if only some could be covered.
-pub fn extend_span_comments_strict(id: &NodeId, span: Span, rcx: &RewriteCtxt) -> Result<Span, Span> {
+pub fn extend_span_comments_strict(id: &NodeId, mut span: Span, rcx: &RewriteCtxt) -> Result<Span, Span> {
     let source_map = rcx.session().source_map();
 
     let comments = match rcx.comments().get(id) {
@@ -516,11 +516,11 @@ pub fn extend_span_comments_strict(id: &NodeId, span: Span, rcx: &RewriteCtxt) -
 
     let mut all_matched = true;
 
-    let mut span = rewind_span_over_whitespace(span, rcx);
     for comment in &before {
+        let cur_span = rewind_span_over_whitespace(span, rcx);
         let comment_size = usize::sum(comment.lines.iter().map(|l| l.len()));
-        let comment_start = BytePos::from_usize(span.lo().to_usize() - comment_size);
-        let comment_span = span.shrink_to_lo().with_lo(comment_start);
+        let comment_start = BytePos::from_usize(cur_span.lo().to_usize() - comment_size);
+        let comment_span = cur_span.shrink_to_lo().with_lo(comment_start);
         let source = match source_map.span_to_snippet(comment_span) {
             Ok(snippet) => snippet,
             Err(_) => {
@@ -529,15 +529,14 @@ pub fn extend_span_comments_strict(id: &NodeId, span: Span, rcx: &RewriteCtxt) -
             }
         };
         let matches = source.lines().zip(&comment.lines).all(|(src_line, comment_line)| {
+            if src_line.trim() != comment_line.trim() {
+                debug!("comment {:?} did not match source {:?}", comment_line, src_line);
+            }
             src_line.trim() == comment_line.trim()
         });
         if matches {
-            // Extend to previous newline because this is an isolated comment
-            let comment_span = rewind_span_over_whitespace(comment_span, rcx);
-
-            span = span.with_lo(comment_span.lo());
+            span = cur_span.with_lo(comment_span.lo());
         } else {
-            debug!("comment {:?} did not match source {:?}", comment, source);
             all_matched = false;
             break;
         }
diff --git a/c2rust-transpile/Cargo.toml b/c2rust-transpile/Cargo.toml
index e96cd34fa7..10d35757f6 100644
--- a/c2rust-transpile/Cargo.toml
+++ b/c2rust-transpile/Cargo.toml
@@ -27,6 +27,7 @@ handlebars = "1.1.0"
 itertools = "0.8"
 pathdiff = "0.1.0"
 regex = "1"
+smallvec = "0.6"
 strum = "0.15"
 strum_macros = "0.15"
 log = "0.4"
diff --git a/c2rust-transpile/src/c_ast/conversion.rs b/c2rust-transpile/src/c_ast/conversion.rs
index a296fcbeb4..c6fc637964 100644
--- a/c2rust-transpile/src/c_ast/conversion.rs
+++ b/c2rust-transpile/src/c_ast/conversion.rs
@@ -343,7 +343,7 @@ impl ConversionContext {
     fn convert(&mut self, untyped_context: &AstContext) -> () {
         for raw_comment in &untyped_context.comments {
             let comment = Located {
-                loc: Some(raw_comment.loc.clone()),
+                loc: Some(raw_comment.loc.into()),
                 kind: raw_comment.string.clone(),
             };
             self.typed_context.comments.push(comment);
diff --git a/c2rust-transpile/src/c_ast/iterators.rs b/c2rust-transpile/src/c_ast/iterators.rs
index 40a2f37c98..735b5f682d 100644
--- a/c2rust-transpile/src/c_ast/iterators.rs
+++ b/c2rust-transpile/src/c_ast/iterators.rs
@@ -1,6 +1,6 @@
 use crate::c_ast::*;
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
 pub enum SomeId {
     Stmt(CStmtId),
     Expr(CExprId),
@@ -291,7 +291,7 @@ fn immediate_children(context: &TypedAstContext, s_or_e: SomeId) -> Vec<SomeId>
     }
 }
 
-fn immediate_children_all_types(context: &TypedAstContext, s_or_e: SomeId) -> Vec<SomeId> {
+pub fn immediate_children_all_types(context: &TypedAstContext, s_or_e: SomeId) -> Vec<SomeId> {
     match s_or_e {
         SomeId::Stmt(stmt_id) => immediate_stmt_children(&context[stmt_id].kind),
         SomeId::Expr(expr_id) => immediate_expr_children_all_types(&context[expr_id].kind),
@@ -371,3 +371,43 @@ impl<'context> Iterator for DFNodes<'context> {
         result
     }
 }
+
+struct VisitNode {
+    id: SomeId,
+    seen: bool,
+}
+
+impl VisitNode {
+    fn new(id: SomeId) -> Self {
+        Self {
+            id,
+            seen: false,
+        }
+    }
+}
+
+pub trait NodeVisitor {
+    /// Visit nodes in pre-order traversal. Returns true if we should traverse
+    /// children. If we are not traversing children, the node will still be
+    /// visited by `post`.
+    fn pre(&mut self, _id: SomeId) -> bool { true }
+    fn post(&mut self, _id: SomeId) {}
+    fn visit_tree(&mut self, context: &TypedAstContext, root: SomeId) {
+        let mut stack = vec![VisitNode::new(root)];
+        while let Some(mut node) = stack.pop() {
+            if !node.seen {
+                let id = node.id;
+                node.seen = true;
+                stack.push(node);
+
+                if self.pre(id) {
+                    let children = immediate_children_all_types(context, id);
+                    // Add children in reverse order since we visit the end of the stack first
+                    stack.extend(children.into_iter().rev().map(VisitNode::new));
+                }
+            } else {
+                self.post(node.id);
+            }
+        }
+    }
+}
diff --git a/c2rust-transpile/src/c_ast/mod.rs b/c2rust-transpile/src/c_ast/mod.rs
index 0888c29e00..8e0929d4c0 100644
--- a/c2rust-transpile/src/c_ast/mod.rs
+++ b/c2rust-transpile/src/c_ast/mod.rs
@@ -1,14 +1,14 @@
 use c2rust_ast_exporter::clang_ast::LRValue;
 use indexmap::{IndexMap, IndexSet};
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::cell::RefCell;
+use std::collections::{HashMap, HashSet};
 use std::cmp::Ordering;
 use std::fmt::{self, Debug, Display};
-use std::iter::FromIterator;
 use std::mem;
 use std::ops::Index;
 use std::path::{Path, PathBuf};
 
-pub use c2rust_ast_exporter::clang_ast::{SrcFile, SrcLoc};
+pub use c2rust_ast_exporter::clang_ast::{SrcFile, SrcLoc, SrcSpan};
 
 #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Copy, Clone)]
 pub struct CTypeId(pub u64);
@@ -34,12 +34,13 @@ pub type CEnumConstantId = CDeclId; // Enum's need to point to child 'DeclKind::
 
 pub use self::conversion::*;
 pub use self::print::Printer;
-use super::diagnostics::Diagnostic;
 
 mod conversion;
 pub mod iterators;
 mod print;
 
+use iterators::{DFNodes, SomeId};
+
 /// AST context containing all of the nodes in the Clang AST
 #[derive(Debug, Clone)]
 pub struct TypedAstContext {
@@ -78,20 +79,19 @@ pub struct TypedAstContext {
 /// Comments associated with a typed AST context
 #[derive(Debug, Clone)]
 pub struct CommentContext {
-    decl_comments: HashMap<CDeclId, Vec<String>>,
-    stmt_comments: HashMap<CStmtId, Vec<String>>,
+    comments_by_file: HashMap<FileId, RefCell<Vec<Located<String>>>>,
 }
 
 #[derive(Debug, Clone)]
-pub struct DisplaySrcLoc {
+pub struct DisplaySrcSpan {
     file: Option<PathBuf>,
-    loc: SrcLoc,
+    loc: SrcSpan,
 }
 
-impl Display for DisplaySrcLoc {
+impl Display for DisplaySrcSpan {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(ref file) = self.file {
-            write!(f, "{}:{}:{}", file.display(), self.loc.line, self.loc.column)
+            write!(f, "{}:{}:{}", file.display(), self.loc.begin_line, self.loc.begin_column)
         } else {
             Debug::fmt(self, f)
         }
@@ -103,10 +103,19 @@ pub type FileId = usize;
 /// Represents some AST node possibly with source location information bundled with it
 #[derive(Debug, Clone)]
 pub struct Located<T> {
-    pub loc: Option<SrcLoc>,
+    pub loc: Option<SrcSpan>,
     pub kind: T,
 }
 
+impl<T> Located<T> {
+    pub fn begin_loc(&self) -> Option<SrcLoc> {
+        self.loc.map(|loc| loc.begin())
+    }
+    pub fn end_loc(&self) -> Option<SrcLoc> {
+        self.loc.map(|loc| loc.end())
+    }
+}
+
 impl TypedAstContext {
     pub fn new(clang_files: &[SrcFile]) -> TypedAstContext {
         let mut files: Vec<SrcFile> = vec![];
@@ -155,9 +164,9 @@ impl TypedAstContext {
         }
     }
 
-    pub fn display_loc(&self, loc: &Option<SrcLoc>) -> Option<DisplaySrcLoc> {
+    pub fn display_loc(&self, loc: &Option<SrcSpan>) -> Option<DisplaySrcSpan> {
         loc.as_ref().map(|loc| {
-            DisplaySrcLoc {
+            DisplaySrcSpan {
                 file: self.files[self.file_map[loc.fileid as usize]].path.clone(),
                 loc: loc.clone(),
             }
@@ -209,7 +218,16 @@ impl TypedAstContext {
     }
 
     pub fn file_id<T>(&self, located: &Located<T>) -> Option<FileId> {
-        located.loc.as_ref().map(|loc| self.file_map[loc.fileid as usize])
+        located.loc.as_ref().and_then(|loc| self.file_map.get(loc.fileid as usize).copied())
+    }
+
+    pub fn get_src_loc(&self, id: SomeId) -> Option<SrcSpan> {
+        match id {
+            SomeId::Stmt(id) => self.index(id).loc,
+            SomeId::Expr(id) => self.index(id).loc,
+            SomeId::Decl(id) => self.index(id).loc,
+            SomeId::Type(id) => self.index(id).loc,
+        }
     }
 
     pub fn iter_decls(&self) -> indexmap::map::Iter<CDeclId, CDecl> {
@@ -434,7 +452,6 @@ impl TypedAstContext {
     }
 
     pub fn prune_unused_decls(&mut self) {
-        use self::iterators::{DFNodes, SomeId};
         // Starting from a set of root declarations, walk each one to find declarations it
         // depends on. Then walk each of those, recursively.
 
@@ -568,7 +585,7 @@ impl TypedAstContext {
                 (None, None) => Ordering::Equal,
                 (None, _) => Ordering::Less,
                 (_, None) => Ordering::Greater,
-                (Some(a), Some(b)) => self.compare_src_locs(a, b),
+                (Some(a), Some(b)) => self.compare_src_locs(&a.begin(), &b.begin()),
             }
         });
         self.c_decls_top = decls_top;
@@ -578,133 +595,107 @@ impl TypedAstContext {
 impl CommentContext {
     pub fn empty() -> CommentContext {
         CommentContext {
-            decl_comments: HashMap::new(),
-            stmt_comments: HashMap::new(),
+            comments_by_file: HashMap::new(),
         }
     }
 
-    // Try to match up every comment with a declaration or a statement
+    /// Build a CommentContext from the comments in this `ast_context`
     pub fn new(ast_context: &mut TypedAstContext) -> CommentContext {
-        // Group and sort declarations by file and by position
-        let mut decls: HashMap<u64, Vec<(SrcLoc, CDeclId)>> = HashMap::new();
-        for (decl_id, ref loc_decl) in &ast_context.c_decls {
-            if let Some(ref loc) = loc_decl.loc {
-                decls
-                    .entry(loc.fileid)
-                    .or_insert(vec![])
-                    .push((loc.clone(), *decl_id));
-            }
-        }
-        decls.iter_mut().for_each(|(_, v)| v.sort());
-
-        // Group and sort statements by file and by position
-        let mut stmts: HashMap<u64, Vec<(SrcLoc, CStmtId)>> = HashMap::new();
-        for (stmt_id, ref loc_stmt) in &ast_context.c_stmts {
-            if let Some(ref loc) = loc_stmt.loc {
-                stmts
-                    .entry(loc.fileid)
-                    .or_insert(vec![])
-                    .push((loc.clone(), *stmt_id));
-            }
-        }
-        stmts.iter_mut().for_each(|(_, v)| v.sort());
-
-        let mut decl_comments_map: HashMap<CDeclId, BTreeMap<SrcLoc, String>> = HashMap::new();
-        let mut stmt_comments_map: HashMap<CStmtId, BTreeMap<SrcLoc, String>> = HashMap::new();
-
-        let empty_vec1 = &vec![];
-        let empty_vec2 = &vec![];
-
-        // Match comments to declarations and statements
-        while let Some(Located { loc, kind: comment }) = ast_context.comments.pop() {
-            if let Some(loc) = loc {
-                let this_file_decls = decls.get(&loc.fileid).unwrap_or(empty_vec1);
-                let this_file_stmts = stmts.get(&loc.fileid).unwrap_or(empty_vec2);
-
-                // Find the closest declaration and statement
-                let decl_ix = this_file_decls
-                    .binary_search_by_key(&loc.line, |&(ref l, _)| l.line)
-                    .unwrap_or_else(|x| x);
-                let stmt_ix = this_file_stmts
-                    .binary_search_by_key(&loc.line, |&(ref l, _)| l.line)
-                    .unwrap_or_else(|x| x);
-
-                let mut insert_decl_comment = |decl_id: CDeclId, loc, comment| {
-                    let decl_id = if let CDeclKind::NonCanonicalDecl { canonical_decl } = ast_context[decl_id].kind {
-                        canonical_decl
-                    } else {
-                        decl_id
-                    };
-                    decl_comments_map
-                        .entry(decl_id)
-                        .or_insert(BTreeMap::new())
-                        .insert(loc, comment);
-                };
-                let mut insert_stmt_comment = |stmt_id: CStmtId, loc, comment| {
-                    stmt_comments_map
-                        .entry(stmt_id)
-                        .or_insert(BTreeMap::new())
-                        .insert(loc, comment);
-                };
-
-                // Prefer the one that is higher up (biasing towards declarations if there is a tie)
-                match (this_file_decls.get(decl_ix), this_file_stmts.get(stmt_ix)) {
-                    (Some(&(ref l1, d)), Some(&(ref l2, s))) => {
-                        if l1 > l2 {
-                            insert_stmt_comment(s, loc, comment);
-                        } else {
-                            insert_decl_comment(d, loc, comment);
-                        }
-                    }
-                    (Some(&(_, d)), None) => {
-                        insert_decl_comment(d, loc, comment);
-                    }
-                    (None, Some(&(_, s))) => {
-                            insert_stmt_comment(s, loc, comment);
-                    }
-                    (None, None) => {
-                        diag!(
-                            Diagnostic::Comments,
-                            "Didn't find a target node for the comment '{}'",
-                            comment,
-                        );
-                    }
-                };
+        let mut comments_by_file: HashMap<FileId, Vec<Located<String>>> = HashMap::new();
+
+        // Group comments by their file
+        for comment in &ast_context.comments {
+            // Comments without a valid FileId are probably clang
+            // compiler-internal definitions
+            if let Some(file_id) = ast_context.file_id(&comment) {
+                comments_by_file
+                    .entry(file_id)
+                    .or_default()
+                    .push(comment.clone());
             }
         }
 
-        // Flatten out the nested comment maps
-        let decl_comments = decl_comments_map
-            .into_iter()
-            .map(|(decl_id, map)| {
-                let mut comments = Vec::from_iter(map);
-                // Sort comments attached to this decl by source location
-                comments.sort_unstable_by(|a, b| {
-                    ast_context.compare_src_locs(&a.0, &b.0)
-                });
+        // Sort in REVERSE! Last element is the first in file source
+        // ordering. This makes it easy to pop the next comment off.
+        for comments in comments_by_file.values_mut() {
+            comments.sort_by(|a, b| {
+                ast_context.compare_src_locs(
+                    &b.loc.unwrap().begin(),
+                    &a.loc.unwrap().begin(),
+                )
+            });
+        }
 
-                (decl_id, comments.into_iter().map(|(_, v)| v).collect())
-            })
-            .collect();
-        let stmt_comments = stmt_comments_map
+        let comments_by_file = comments_by_file
             .into_iter()
-            .map(|(decl_id, map)| (decl_id, map.into_iter().map(|(_, v)| v).collect()))
+            .map(|(k, v)| (k, RefCell::new(v)))
             .collect();
 
         CommentContext {
-            decl_comments,
-            stmt_comments,
+            comments_by_file,
+        }
+    }
+
+    pub fn get_comments_before(&self, loc: SrcLoc, ctx: &TypedAstContext) -> Vec<String> {
+        let file_id = ctx.file_map[loc.fileid as usize];
+        let mut extracted_comments = vec![];
+        let mut comments = match self.comments_by_file.get(&file_id) {
+            None => return extracted_comments,
+            Some(comments) => comments.borrow_mut(),
+        };
+        while !comments.is_empty() {
+            let next_comment_loc = comments
+                .last()
+                .unwrap()
+                .begin_loc()
+                .expect("All comments must have a source location");
+            if ctx.compare_src_locs(&next_comment_loc, &loc) != Ordering::Less {
+                break;
+            }
+
+            extracted_comments.push(comments.pop().unwrap().kind);
         }
+        extracted_comments
     }
 
-    // Extract the comment for a given declaration
-    pub fn get_decl_comment(&self, decl_id: CDeclId) -> Option<&[String]> {
-        self.decl_comments.get(&decl_id).map(Vec::as_ref)
+    pub fn get_comments_before_located<T>(
+        &self,
+        located: &Located<T>,
+        ctx: &TypedAstContext,
+    ) -> Vec<String> {
+        match located.begin_loc() {
+            None => vec![],
+            Some(loc) => self.get_comments_before(loc, ctx),
+        }
     }
 
-    // Extract the comment for a given statement
-    pub fn get_stmt_comment(&self, stmt_id: CStmtId) -> Option<&[String]> {
-        self.stmt_comments.get(&stmt_id).map(Vec::as_ref)
+    pub fn peek_next_comment_on_line(&self, loc: SrcLoc, ctx: &TypedAstContext) -> Option<Located<String>> {
+        let file_id = ctx.file_map[loc.fileid as usize];
+        let comments = self.comments_by_file.get(&file_id)?.borrow();
+        comments.last().and_then(|comment| {
+            let next_comment_loc = comment
+                .begin_loc()
+                .expect("All comments must have a source location");
+            if next_comment_loc.line != loc.line {
+                None
+            } else {
+                Some(comment.clone())
+            }
+        })
+    }
+
+    /// Advance over the current comment in `file`
+    pub fn advance_comment(&self, file: FileId) {
+        if let Some(comments) = self.comments_by_file.get(&file) {
+            let _ = comments.borrow_mut().pop();
+        }
+    }
+
+    pub fn get_remaining_comments(&mut self, file_id: FileId) -> Vec<String> {
+        match self.comments_by_file.remove(&file_id) {
+            Some(comments) => comments.into_inner().into_iter().map(|c| c.kind).collect(),
+            None => vec![],
+        }
     }
 }
 
diff --git a/c2rust-transpile/src/cfg/mod.rs b/c2rust-transpile/src/cfg/mod.rs
index f529204731..f97aa0790d 100644
--- a/c2rust-transpile/src/cfg/mod.rs
+++ b/c2rust-transpile/src/cfg/mod.rs
@@ -30,7 +30,7 @@ use syntax;
 use syntax::ast::{Arm, Expr, ExprKind, Lit, LitIntType, LitKind, Pat, Stmt, StmtKind};
 use syntax::print::pprust;
 use syntax::ptr::P;
-use syntax_pos::DUMMY_SP;
+use syntax_pos::{DUMMY_SP, Span};
 
 use indexmap::{IndexMap, IndexSet};
 
@@ -113,7 +113,7 @@ impl StructureLabel<StmtOrDecl> {
         self,
         lift_me: &IndexSet<CDeclId>,
         store: &mut DeclStmtStore,
-    ) -> StructureLabel<StmtOrComment> {
+    ) -> StructureLabel<Stmt> {
         match self {
             StructureLabel::GoTo(l) => StructureLabel::GoTo(l),
             StructureLabel::ExitTo(l) => StructureLabel::ExitTo(l),
@@ -135,6 +135,7 @@ pub enum Structure<Stmt> {
     Simple {
         entries: IndexSet<Label>,
         body: Vec<Stmt>,
+        span: Span,
         terminator: GenTerminator<StructureLabel<Stmt>>,
     },
     /// Looping constructs
@@ -167,16 +168,17 @@ impl Structure<StmtOrDecl> {
         self,
         lift_me: &IndexSet<CDeclId>,
         store: &mut DeclStmtStore,
-    ) -> Structure<StmtOrComment> {
+    ) -> Structure<Stmt> {
         match self {
             Structure::Simple {
                 entries,
                 body,
+                span,
                 terminator,
             } => {
                 let body = body
                     .into_iter()
-                    .flat_map(|s: StmtOrDecl| -> Vec<StmtOrComment> {
+                    .flat_map(|s: StmtOrDecl| -> Vec<Stmt> {
                         s.place_decls(lift_me, store)
                     })
                     .collect();
@@ -184,6 +186,7 @@ impl Structure<StmtOrDecl> {
                 Structure::Simple {
                     entries,
                     body,
+                    span,
                     terminator,
                 }
             }
@@ -238,6 +241,9 @@ pub struct BasicBlock<L, S> {
 
     /// Variables defined in this block
     defined: IndexSet<CDeclId>,
+
+    /// Span of this block
+    span: Span,
 }
 
 impl<L: Clone, S1> BasicBlock<L, S1> {
@@ -249,6 +255,7 @@ impl<L: Clone, S1> BasicBlock<L, S1> {
             terminator: self.terminator.clone(),
             live: self.live.clone(),
             defined: self.defined.clone(),
+            span: self.span,
         }
     }
 }
@@ -269,6 +276,7 @@ impl<L, S> BasicBlock<L, S> {
             terminator,
             live: IndexSet::new(),
             defined: IndexSet::new(),
+            span: DUMMY_SP,
         }
     }
 
@@ -399,7 +407,7 @@ impl GenTerminator<StructureLabel<StmtOrDecl>> {
         self,
         lift_me: &IndexSet<CDeclId>,
         store: &mut DeclStmtStore,
-    ) -> GenTerminator<StructureLabel<StmtOrComment>> {
+    ) -> GenTerminator<StructureLabel<Stmt>> {
         match self {
             End => End,
             Jump(l) => {
@@ -438,9 +446,6 @@ pub enum StmtOrDecl {
 
     /// C declaration
     Decl(CDeclId),
-
-    /// Comment
-    Comment(String),
 }
 
 impl StmtOrDecl {
@@ -451,21 +456,10 @@ impl StmtOrDecl {
                 let ss = store.peek_decl_and_assign(*d).unwrap();
                 ss.iter().map(pprust::stmt_to_string).collect()
             }
-            StmtOrDecl::Comment(ref s) => vec![s.clone()],
         }
     }
 }
 
-/// A Rust statement, or a comment
-#[derive(Clone, Debug)]
-pub enum StmtOrComment {
-    /// Rust statement
-    Stmt(Stmt),
-
-    /// Comment
-    Comment(String),
-}
-
 impl StmtOrDecl {
     /// Produce a `Stmt` by replacing `StmtOrDecl::Decl`  variants with either a declaration with
     /// initializer or only an initializer.
@@ -473,21 +467,18 @@ impl StmtOrDecl {
         self,
         lift_me: &IndexSet<CDeclId>,
         store: &mut DeclStmtStore,
-    ) -> Vec<StmtOrComment> {
+    ) -> Vec<Stmt> {
         match self {
-            StmtOrDecl::Stmt(s) => vec![StmtOrComment::Stmt(s)],
-            StmtOrDecl::Comment(c) => vec![StmtOrComment::Comment(c)],
+            StmtOrDecl::Stmt(s) => vec![s],
             StmtOrDecl::Decl(d) if lift_me.contains(&d) => store
                 .extract_assign(d)
                 .unwrap()
                 .into_iter()
-                .map(StmtOrComment::Stmt)
                 .collect(),
             StmtOrDecl::Decl(d) => store
                 .extract_decl_and_assign(d)
                 .unwrap()
                 .into_iter()
-                .map(StmtOrComment::Stmt)
                 .collect(),
         }
     }
@@ -744,6 +735,15 @@ impl<Lbl: Copy + Ord + Hash + Debug, Stmt> Cfg<Lbl, Stmt> {
             // It makes no sense to remap something to itself
             for from in from_any {
                 if from != to_final {
+                    let span = self.nodes[&from].span;
+                    let tgt_span = &mut self.nodes[&to_final].span;
+                    if tgt_span.is_dummy() {
+                        *tgt_span = span;
+                    } else if !span.is_dummy() {
+                        // If we can't transfer this basic block's span to the
+                        // target, don't delete it
+                        continue;
+                    }
                     actual_rewrites.insert(from, to_final);
                 }
             }
@@ -1123,6 +1123,9 @@ struct WipBlock {
 
     /// Variables live in this WIP.
     live: IndexSet<CDeclId>,
+
+    /// Span of this block
+    span: Span,
 }
 
 impl Extend<Stmt> for WipBlock {
@@ -1141,10 +1144,6 @@ impl WipBlock {
     pub fn push_decl(&mut self, decl: CDeclId) {
         self.body.push(StmtOrDecl::Decl(decl))
     }
-
-    pub fn push_comment(&mut self, cmmt: String) {
-        self.body.push(StmtOrDecl::Comment(cmmt))
-    }
 }
 
 /// This impl block deals with creating control flow graphs
@@ -1193,6 +1192,7 @@ impl CfgBuilder {
             body,
             defined,
             live,
+            span,
         } = wip;
         self.add_block(
             label,
@@ -1201,6 +1201,7 @@ impl CfgBuilder {
                 terminator,
                 defined,
                 live,
+                span,
             },
         );
     }
@@ -1289,6 +1290,7 @@ impl CfgBuilder {
             body: vec![],
             defined: IndexSet::new(),
             live: self.current_variables(),
+            span: DUMMY_SP,
         }
     }
 
@@ -1385,12 +1387,7 @@ impl CfgBuilder {
 
         let mut wip = self.new_wip_block(entry);
 
-        // Add statement comment into current block right before the current statement
-        if let Some(comments) = translator.comment_context.get_stmt_comment(stmt_id) {
-            for cmmt in comments {
-                wip.push_comment(cmmt.clone());
-            }
-        }
+        wip.span = translator.get_span(SomeId::Stmt(stmt_id)).unwrap_or(DUMMY_SP);
 
         let out_wip: Result<Option<WipBlock>, TranslationError> =
             match translator.ast_context.index(stmt_id).kind {
@@ -1404,16 +1401,6 @@ impl CfgBuilder {
                             .store
                             .insert(*decl, info);
 
-                        // Add declaration comment into current block right before the declaration
-                        if let Some(comments) = translator
-                            .comment_context
-                            .get_decl_comment(*decl)
-                        {
-                            for cmmt in comments {
-                                wip.push_comment(cmmt.clone());
-                            }
-                        }
-
                         wip.push_decl(*decl);
                         wip.defined.insert(*decl);
                     }
@@ -1451,6 +1438,7 @@ impl CfgBuilder {
                     // Condition
                     let (stmts, val) = translator.convert_condition(ctx, true, scrutinee)?.discard_unsafe();
                     wip.extend(stmts);
+
                     let cond_val = translator.ast_context[scrutinee].kind.get_bool();
                     self.add_wip_block(
                         wip,
@@ -1507,6 +1495,7 @@ impl CfgBuilder {
                     let cond_val = translator.ast_context[condition].kind.get_bool();
                     let mut cond_wip = self.new_wip_block(cond_entry);
                     cond_wip.extend(stmts);
+
                     self.add_wip_block(
                         cond_wip,
                         match cond_val {
@@ -2000,6 +1989,8 @@ impl CfgBuilder {
             false,
         )?;
 
+        let inner_span = stmts.first().map(|stmt| stmt.span);
+
         // Remove unnecessary break statements. We only need a break statement if we failed to
         // remove the tail expr.
         let need_block =
@@ -2013,6 +2004,17 @@ impl CfgBuilder {
         }
 
         let mut flattened_wip = self.new_wip_block(entry);
+        // Copy span from removed statement if there was only one.
+        if stmts.is_empty() {
+            if let Some(span) = inner_span {
+                // We move any comments on the high end of the span to the low,
+                // because those comments should go before the next node, not after.
+                flattened_wip.span = translator
+                    .comment_store
+                    .borrow_mut()
+                    .move_comments_to_begin(span);
+            }
+        }
         flattened_wip.extend(stmts);
         let term = if let Some(l) = next_lbl {
             GenTerminator::Jump(l)
diff --git a/c2rust-transpile/src/cfg/relooper.rs b/c2rust-transpile/src/cfg/relooper.rs
index df26c05903..7fe285f573 100644
--- a/c2rust-transpile/src/cfg/relooper.rs
+++ b/c2rust-transpile/src/cfg/relooper.rs
@@ -11,7 +11,7 @@ pub fn reloop(
     use_c_loop_info: bool,       // use the loop information in the CFG (slower, but better)
     use_c_multiple_info: bool,   // use the multiple information in the CFG (slower, but better)
     live_in: IndexSet<CDeclId>,  // declarations we assume are live going into this graph
-) -> (Vec<Stmt>, Vec<Structure<StmtOrComment>>) {
+) -> (Vec<Stmt>, Vec<Structure<Stmt>>) {
     let entries: IndexSet<Label> = vec![cfg.entries].into_iter().collect();
     let blocks = cfg
         .nodes
@@ -25,6 +25,7 @@ pub fn reloop(
                     terminator,
                     defined: bb.defined,
                     live: bb.live,
+                    span: bb.span,
                 },
             )
         })
@@ -54,7 +55,7 @@ pub fn reloop(
         .collect();
 
     // We map over the existing structure and flatten everything to `Stmt`
-    let mut relooped: Vec<Structure<StmtOrComment>> = relooped_with_decls
+    let mut relooped: Vec<Structure<Stmt>> = relooped_with_decls
         .into_iter()
         .map(|s| s.place_decls(&lift_me, &mut store))
         .collect();
@@ -194,6 +195,7 @@ impl RelooperState {
                     terminator,
                     live,
                     defined,
+                    span,
                 } = bb;
 
                 // Flag declarations for everything that is live going in but not already in scope.
@@ -216,6 +218,7 @@ impl RelooperState {
                 result.push(Structure::Simple {
                     entries,
                     body,
+                    span,
                     terminator,
                 });
 
@@ -227,6 +230,7 @@ impl RelooperState {
                 result.push(Structure::Simple {
                     entries,
                     body,
+                    span: DUMMY_SP,
                     terminator,
                 });
             };
@@ -544,6 +548,7 @@ fn simplify_structure<Stmt: Clone>(structures: Vec<Structure<Stmt>>) -> Vec<Stru
             &Structure::Simple {
                 ref entries,
                 ref body,
+                ref span,
                 ref terminator,
             } => {
                 // Here, we ensure that all labels in a terminator are mentioned only once in the
@@ -612,6 +617,7 @@ fn simplify_structure<Stmt: Clone>(structures: Vec<Structure<Stmt>>) -> Vec<Stru
                                 let first_structure = Structure::Simple {
                                     entries,
                                     body,
+                                    span: DUMMY_SP,
                                     terminator,
                                 };
 
@@ -626,10 +632,12 @@ fn simplify_structure<Stmt: Clone>(structures: Vec<Structure<Stmt>>) -> Vec<Stru
 
                         let terminator = terminator.map_labels(rewrite);
                         let body = body.clone();
+                        let span = *span;
                         let entries = entries.clone();
                         acc_structures.push(Structure::Simple {
                             entries,
                             body,
+                            span,
                             terminator,
                         });
                     }
@@ -640,10 +648,12 @@ fn simplify_structure<Stmt: Clone>(structures: Vec<Structure<Stmt>>) -> Vec<Stru
 
                         let entries = entries.clone();
                         let body = body.clone();
+                        let span = *span;
                         let terminator = terminator.clone();
                         acc_structures.push(Structure::Simple {
                             entries,
                             body,
+                            span,
                             terminator,
                         });
                     }
diff --git a/c2rust-transpile/src/cfg/structures.rs b/c2rust-transpile/src/cfg/structures.rs
index 5e7ad72318..398c83c988 100644
--- a/c2rust-transpile/src/cfg/structures.rs
+++ b/c2rust-transpile/src/cfg/structures.rs
@@ -1,31 +1,28 @@
 //! This modules handles converting `Vec<Structure>` into `Vec<Stmt>`.
 
+use syntax::source_map::{dummy_spanned, Spanned};
+use syntax_pos::BytePos;
+
 use super::*;
 
 use crate::rust_ast::comment_store;
 
 /// Convert a sequence of structures produced by Relooper back into Rust statements
 pub fn structured_cfg(
-    root: &Vec<Structure<StmtOrComment>>,
+    root: &Vec<Structure<Stmt>>,
     comment_store: &mut comment_store::CommentStore,
     current_block: P<Expr>,
     debug_labels: bool,
     cut_out_trailing_ret: bool,
 ) -> Result<Vec<Stmt>, TranslationError> {
-    let ast: StructuredAST<P<Expr>, P<Pat>, Label, StmtOrComment> =
+    let ast: StructuredAST<P<Expr>, P<Pat>, Label, Stmt> =
         structured_cfg_help(vec![], &IndexSet::new(), root, &mut IndexSet::new())?;
 
     let s = StructureState {
-        enable_comments: true,
         debug_labels,
         current_block,
     };
-    let mut queued = vec![];
-    let mut stmts = vec![];
-    s.into_stmt(ast, comment_store, &mut queued, &mut stmts);
-    if !queued.is_empty() {
-        eprintln!("Did not find a statement for comments {:?}", queued);
-    }
+    let (mut stmts, _span) = s.into_stmt(ast, comment_store);
 
     // If the very last statement in the vector is a `return`, we can either cut it out or replace
     // it with the returned value.
@@ -117,11 +114,16 @@ pub trait StructuredStatement: Sized {
         exit_style: ExitStyle,  // `break` or a `continue`
         label: Option<Self::L>, // which loop are we breaking
     ) -> Self;
+
+    fn extend_span(&mut self, span: Span);
 }
 
+pub type StructuredAST<E, P, L, S> = Spanned<StructuredASTKind<E, P, L, S>>;
+
 /// Defunctionalized version of `StructuredStatement` trait
 #[allow(missing_docs)]
-pub enum StructuredAST<E, P, L, S> {
+#[derive(Debug)]
+pub enum StructuredASTKind<E, P, L, S> {
     Empty,
     Singleton(S),
     Append(
@@ -150,39 +152,50 @@ impl<E, P, L, S> StructuredStatement for StructuredAST<E, P, L, S> {
     type S = S;
 
     fn empty() -> Self {
-        StructuredAST::Empty
+        dummy_spanned(StructuredASTKind::Empty)
     }
 
     fn mk_singleton(stmt: Self::S) -> Self {
-        StructuredAST::Singleton(stmt)
+        dummy_spanned(StructuredASTKind::Singleton(stmt))
     }
 
     fn mk_append(self, second: Self) -> Self {
-        StructuredAST::Append(Box::new(self), Box::new(second))
+        dummy_spanned(StructuredASTKind::Append(Box::new(self), Box::new(second)))
     }
 
     fn mk_goto(to: Self::L) -> Self {
-        StructuredAST::Goto(to)
+        dummy_spanned(StructuredASTKind::Goto(to))
     }
 
     fn mk_match(cond: Self::E, cases: Vec<(Vec<Self::P>, Self)>) -> Self {
-        StructuredAST::Match(cond, cases)
+        dummy_spanned(StructuredASTKind::Match(cond, cases))
     }
 
     fn mk_if(cond: Self::E, then: Self, else_: Self) -> Self {
-        StructuredAST::If(cond, Box::new(then), Box::new(else_))
+        dummy_spanned(StructuredASTKind::If(cond, Box::new(then), Box::new(else_)))
     }
 
     fn mk_goto_table(cases: Vec<(Self::L, Self)>, then: Self) -> Self {
-        StructuredAST::GotoTable(cases, Box::new(then))
+        dummy_spanned(StructuredASTKind::GotoTable(cases, Box::new(then)))
     }
 
     fn mk_loop(lbl: Option<Self::L>, body: Self) -> Self {
-        StructuredAST::Loop(lbl, Box::new(body))
+        dummy_spanned(StructuredASTKind::Loop(lbl, Box::new(body)))
     }
 
     fn mk_exit(exit_style: ExitStyle, label: Option<Self::L>) -> Self {
-        StructuredAST::Exit(exit_style, label)
+        dummy_spanned(StructuredASTKind::Exit(exit_style, label))
+    }
+
+    fn extend_span(&mut self, span: Span) {
+        if !self.span.is_dummy() {
+            self.span = span_subst_hi(self.span, span).unwrap_or_else(|| {
+                warn!("Could not extend span {:?} to {:?}", self.span, span);
+                self.span
+            });
+        } else {
+            self.span = span;
+        }
     }
 }
 
@@ -190,11 +203,11 @@ impl<E, P, L, S> StructuredStatement for StructuredAST<E, P, L, S> {
 ///
 /// TODO: move this into `structured_cfg`?
 fn structured_cfg_help<
-    S: StructuredStatement<E = P<Expr>, P = P<Pat>, L = Label, S = StmtOrComment>,
+    S: StructuredStatement<E = P<Expr>, P = P<Pat>, L = Label, S = Stmt>,
 >(
     exits: Vec<(Label, IndexMap<Label, (IndexSet<Label>, ExitStyle)>)>,
     next: &IndexSet<Label>,
-    root: &Vec<Structure<StmtOrComment>>,
+    root: &Vec<Structure<Stmt>>,
     used_loop_labels: &mut IndexSet<Label>,
 ) -> Result<S, TranslationError> {
     let mut next: &IndexSet<Label> = next;
@@ -207,11 +220,13 @@ fn structured_cfg_help<
             &Structure::Simple {
                 ref body,
                 ref terminator,
+                ref span,
                 ..
             } => {
                 for s in body.clone() {
                     new_rest = S::mk_append(new_rest, S::mk_singleton(s));
                 }
+                new_rest.extend_span(*span);
 
                 let insert_goto = |to: Label, target: &IndexSet<Label>| -> S {
                     if target.len() == 1 {
@@ -222,7 +237,7 @@ fn structured_cfg_help<
                 };
 
                 let mut branch =
-                    |slbl: &StructureLabel<StmtOrComment>| -> Result<S, TranslationError> {
+                    |slbl: &StructureLabel<Stmt>| -> Result<S, TranslationError> {
                         match slbl {
                             &StructureLabel::Nested(ref nested) => {
                                 structured_cfg_help(exits.clone(), next, nested, used_loop_labels)
@@ -245,10 +260,12 @@ fn structured_cfg_help<
                                             Some(label)
                                         };
 
-                                        return Ok(S::mk_append(
+                                        let mut new_cfg = S::mk_append(
                                             insert_goto(to, follow),
                                             S::mk_exit(exit_style, lbl),
-                                        ));
+                                        );
+                                        new_cfg.extend_span(*span);
+                                        return Ok(new_cfg);
                                     }
                                     immediate = false;
                                 }
@@ -367,80 +384,133 @@ pub fn has_multiple<Stmt>(root: &Vec<Structure<Stmt>>) -> bool {
 }
 
 struct StructureState {
-    enable_comments: bool,
     debug_labels: bool,
     current_block: P<Expr>,
 }
 
+/// Returns a `Span` between the beginning of `span` or `other`, whichever is
+/// non-zero, and the end of `span`. If both `span` and `other` have non-zero
+/// beginnings, return `None`.
+fn span_subst_lo(span: Span, other: Span) -> Option<Span> {
+    if span.is_dummy() {
+        return Some(other.shrink_to_lo());
+    } else if span.lo() == BytePos(0) {
+        return Some(span.between(other));
+    } else if other.lo() != BytePos(0) && other.lo() != span.lo() {
+        return None;
+    }
+    Some(span)
+}
+
+/// Returns a `Span` between the beginning of `span` and the end of `span` or
+/// `other`, whichever is non-zero. If both `span` and `other` have non-zero
+/// endings, return `None`.
+fn span_subst_hi(span: Span, other: Span) -> Option<Span> {
+    if other.lo() != other.hi() {
+        if span.lo() == span.hi() {
+            return Some(other.between(span));
+        } else if other.hi() != span.hi() {
+            return None;
+        }
+    }
+    Some(span)
+}
+
 impl StructureState {
     pub fn into_stmt(
         &self,
-        ast: StructuredAST<P<Expr>, P<Pat>, Label, StmtOrComment>,
+        ast: StructuredAST<P<Expr>, P<Pat>, Label, Stmt>,
         comment_store: &mut comment_store::CommentStore,
-        queued_comments: &mut Vec<String>,
-        output: &mut Vec<Stmt>,
-    ) {
-        use crate::cfg::structures::StructuredAST::*;
+    ) -> (Vec<Stmt>, Span) {
+        use crate::cfg::structures::StructuredASTKind::*;
 
-        match ast {
-            Empty => {}
+        let span = ast.span;
 
-            Singleton(StmtOrComment::Comment(c)) => {
-                if self.enable_comments {
-                    queued_comments.push(c);
-                }
+        let stmt = match ast.node {
+            Empty => return (vec![], ast.span),
+
+            Singleton(mut s) => {
+                let span = s.span.substitute_dummy(ast.span);
+                s.span = span;
+                return (vec![s], span);
             }
-            Singleton(StmtOrComment::Stmt(mut s)) => {
-                s.span = comment_store.add_comment_lines(&queued_comments).unwrap_or(s.span);
-                queued_comments.clear();
-                output.push(s);
+
+            Append(box Spanned {node: Empty, span: lhs_span}, rhs) => {
+                let span = ast.span.substitute_dummy(lhs_span);
+                let span = span_subst_lo(span, lhs_span).unwrap_or_else(|| {
+                    comment_store.move_comments(lhs_span.lo(), span.lo());
+                    span
+                });
+
+                let (mut stmts, stmts_span) = self.into_stmt(*rhs, comment_store);
+                let span = span_subst_hi(span, stmts_span).unwrap_or(span);
+
+                // Adjust the first and last elements of the block if this AST
+                // node has a span.
+                if let Some(stmt) = stmts.first_mut() {
+                    stmt.span = span_subst_lo(stmt.span, span).unwrap_or_else(|| {
+                        comment_store.move_comments(stmt.span.lo(), span.lo());
+                        stmt.span.with_lo(span.lo())
+                    });
+                }
+                if let Some(stmt) = stmts.last_mut() {
+                    stmt.span = span_subst_hi(stmt.span, span).unwrap_or(stmt.span);
+                }
+                return (stmts, span);
             }
 
             Append(lhs, rhs) => {
-                self.into_stmt(*lhs, comment_store, queued_comments, output);
-                self.into_stmt(*rhs, comment_store, queued_comments, output);
+                let (mut stmts, lhs_span) = self.into_stmt(*lhs, comment_store);
+                let span = ast.span.substitute_dummy(lhs_span);
+                let span = span_subst_lo(span, lhs_span).unwrap_or_else(|| {
+                    comment_store.move_comments(lhs_span.lo(), span.lo());
+                    span
+                });
+                let (rhs_stmts, rhs_span) = self.into_stmt(*rhs, comment_store);
+                let span = span_subst_hi(span, rhs_span).unwrap_or(span);
+                stmts.extend(rhs_stmts);
+                // Adjust the first and last elements of the block if this AST
+                // node has a span.
+                if let Some(stmt) = stmts.first_mut() {
+                    stmt.span = span_subst_lo(stmt.span, span).unwrap_or_else(|| {
+                        comment_store.move_comments(stmt.span.lo(), span.lo());
+                        stmt.span.with_lo(span.lo())
+                    });
+                }
+                if let Some(stmt) = stmts.last_mut() {
+                    stmt.span = span_subst_hi(stmt.span, span).unwrap_or(stmt.span);
+                }
+                return (stmts, span);
             }
 
             Goto(to) => {
                 // Assign to `current_block` the next label we want to go to.
 
-                let s = comment_store.add_comment_lines(&queued_comments).unwrap_or(DUMMY_SP);
-                queued_comments.clear();
-
                 let lbl_expr = if self.debug_labels {
                     to.to_string_expr()
                 } else {
                     to.to_num_expr()
                 };
-                output.push(
-                    mk().span(s)
-                        .semi_stmt(mk().assign_expr(self.current_block.clone(), lbl_expr)),
-                );
+                mk().span(span)
+                    .semi_stmt(mk().assign_expr(self.current_block.clone(), lbl_expr))
             }
 
             Match(cond, cases) => {
                 // Make a `match`.
 
-                let s = comment_store.add_comment_lines(&queued_comments).unwrap_or(DUMMY_SP);
-                queued_comments.clear();
-
                 let arms: Vec<Arm> = cases
                     .into_iter()
                     .map(|(pats, stmts)| -> Arm {
-                        let stmts = {
-                            let mut output = vec![];
-                            self.into_stmt(stmts, comment_store, queued_comments, &mut output);
-                            output
-                        };
+                        let (stmts, span) = self.into_stmt(stmts, comment_store);
 
-                        let body = mk().block_expr(mk().block(stmts));
+                        let body = mk().block_expr(mk().span(span).block(stmts));
                         mk().arm(pats, None as Option<P<Expr>>, body)
                     })
                     .collect();
 
                 let e = mk().match_expr(cond, arms);
 
-                output.push(mk().span(s).expr_stmt(e));
+                mk().span(span).expr_stmt(e)
             }
 
             If(cond, then, els) => {
@@ -451,76 +521,69 @@ impl StructureState {
                 //   * `if <cond-expr> { } else { .. }` turns into `if !<cond-expr> { .. }`
                 //
 
-                let s = comment_store.add_comment_lines(&queued_comments).unwrap_or(DUMMY_SP);
-                queued_comments.clear();
+                let (then_stmts, then_span) = self.into_stmt(*then, comment_store);
 
-                let then = {
-                    let mut output = vec![];
-                    self.into_stmt(*then, comment_store, queued_comments, &mut output);
-                    output
-                };
-
-                let mut els = {
-                    let mut output = vec![];
-                    self.into_stmt(*els, comment_store, queued_comments, &mut output);
-                    output
-                };
+                let (mut els_stmts, els_span) = self.into_stmt(*els, comment_store);
 
-                let mut if_stmt = match (then.is_empty(), els.is_empty()) {
+                let mut if_stmt = match (then_stmts.is_empty(), els_stmts.is_empty()) {
                     (true, true) => mk().semi_stmt(cond),
                     (false, true) => {
                         let if_expr =
-                            mk().ifte_expr(cond, mk().block(then), None as Option<P<Expr>>);
+                            mk().ifte_expr(cond, mk().span(then_span).block(then_stmts), None as Option<P<Expr>>);
                         mk().expr_stmt(if_expr)
                     }
                     (true, false) => {
                         let negated_cond = not(&cond);
                         let if_expr =
-                            mk().ifte_expr(negated_cond, mk().block(els), None as Option<P<Expr>>);
+                            mk().ifte_expr(negated_cond, mk().span(els_span).block(els_stmts), None as Option<P<Expr>>);
                         mk().expr_stmt(if_expr)
                     }
                     (false, false) => {
                         fn is_expr(kind: &StmtKind) -> bool {
-                            match kind {
-                                &StmtKind::Expr(_) => true,
+                            match &kind {
+                                StmtKind::Expr(expr) => match &expr.node {
+                                    ExprKind::If(..) | ExprKind::IfLet(..)
+                                    | ExprKind::Block(..) => true,
+                                    _ => false,
+                                },
                                 _ => false,
                             }
                         }
 
-                        let is_els_expr = els.len() == 1 && is_expr(&els[0].node);
+                        // Do the else statemtents contain a single If, IfLet or
+                        // Block expression? The pretty printer handles only
+                        // these kinds of expressions for the else case.
+                        let is_els_expr = els_stmts.len() == 1 && is_expr(&els_stmts[0].node);
 
                         let els_branch = if is_els_expr {
-                            match els.swap_remove(0).node {
+                            let stmt_expr = els_stmts.swap_remove(0);
+                            let stmt_expr_span = stmt_expr.span;
+                            let mut els_expr = match stmt_expr.node {
                                 StmtKind::Expr(e) => e,
                                 _ => panic!("is_els_expr out of sync"),
-                            }
+                            };
+                            els_expr.span = stmt_expr_span;
+                            els_expr
                         } else {
-                            mk().block_expr(mk().block(els))
+                            mk().block_expr(mk().span(els_span).block(els_stmts))
                         };
 
-                        let if_expr = mk().ifte_expr(cond, mk().block(then), Some(els_branch));
+                        let if_expr = mk().ifte_expr(cond, mk().span(then_span).block(then_stmts), Some(els_branch));
                         mk().expr_stmt(if_expr)
                     }
                 };
 
-                if_stmt.span = s;
-                output.push(if_stmt);
+                if_stmt.span = span;
+                if_stmt
             }
 
             GotoTable(cases, then) => {
                 // Dispatch based on the next `current_block` value.
 
-                let s = comment_store.add_comment_lines(&queued_comments).unwrap_or(DUMMY_SP);
-                queued_comments.clear();
-
                 let mut arms: Vec<Arm> = cases
                     .into_iter()
                     .map(|(lbl, stmts)| -> Arm {
-                        let stmts = {
-                            let mut output = vec![];
-                            self.into_stmt(stmts, comment_store, queued_comments, &mut output);
-                            output
-                        };
+                        let (stmts, stmts_span) = self.into_stmt(stmts, comment_store);
 
                         let lbl_expr = if self.debug_labels {
                             lbl.to_string_expr()
@@ -528,26 +591,22 @@ impl StructureState {
                             lbl.to_num_expr()
                         };
                         let pat = mk().lit_pat(lbl_expr);
-                        let body = mk().block_expr(mk().block(stmts));
+                        let body = mk().block_expr(mk().span(stmts_span).block(stmts));
                         mk().arm(vec![pat], None as Option<P<Expr>>, body)
                     })
                     .collect();
 
-                let then = {
-                    let mut output = vec![];
-                    self.into_stmt(*then, comment_store, queued_comments, &mut output);
-                    output
-                };
+                let (then, then_span) = self.into_stmt(*then, comment_store);
 
                 arms.push(mk().arm(
                     vec![mk().wild_pat()],
                     None as Option<P<Expr>>,
-                    mk().block_expr(mk().block(then)),
+                    mk().block_expr(mk().span(then_span).block(then)),
                 ));
 
                 let e = mk().match_expr(self.current_block.clone(), arms);
 
-                output.push(mk().span(s).expr_stmt(e));
+                mk().span(span).expr_stmt(e)
             }
 
             Loop(lbl, body) => {
@@ -556,21 +615,16 @@ impl StructureState {
                 //   * Loops that start with an `if <cond-expr> { break; }` get converted into `while` loops
                 //
 
-                let s = comment_store.add_comment_lines(&queued_comments).unwrap_or(DUMMY_SP);
-                queued_comments.clear();
-
-                let body = {
-                    let mut output = vec![];
-                    self.into_stmt(*body, comment_store, queued_comments, &mut output);
-                    output
-                };
+                let (body, body_span) = self.into_stmt(*body, comment_store);
 
                 // TODO: this is ugly but it needn't be. We are just pattern matching on particular ASTs.
                 if let Some(&Stmt {
                     node: syntax::ast::StmtKind::Expr(ref expr),
+                    span: stmt_span,
                     ..
-                }) = body.iter().nth(0)
+                }) = body.first()
                 {
+                    let span = if !stmt_span.is_dummy() { stmt_span } else { span };
                     if let syntax::ast::ExprKind::If(ref cond, ref thn, None) = expr.node {
                         if let &syntax::ast::Block {
                             ref stmts,
@@ -587,11 +641,10 @@ impl StructureState {
                                     if let syntax::ast::ExprKind::Break(None, None) = expr.node {
                                         let e = mk().while_expr(
                                             not(cond),
-                                            mk().block(body.iter().skip(1).cloned().collect()),
+                                            mk().span(body_span).block(body.iter().skip(1).cloned().collect()),
                                             lbl.map(|l| l.pretty_print()),
                                         );
-                                        output.push(mk().span(s).expr_stmt(e));
-                                        return;
+                                        return (vec![mk().span(span).expr_stmt(e)], ast.span);
                                     }
                                 }
                             }
@@ -599,26 +652,25 @@ impl StructureState {
                     }
                 }
 
-                let e = mk().loop_expr(mk().block(body), lbl.map(|l| l.pretty_print()));
+                let e = mk().loop_expr(mk().span(body_span).block(body), lbl.map(|l| l.pretty_print()));
 
-                output.push(mk().span(s).expr_stmt(e));
+                mk().span(span).expr_stmt(e)
             }
 
             Exit(exit_style, lbl) => {
                 // Make a (possibly labelled) `break` or `continue`.
 
-                let s = comment_store.add_comment_lines(&queued_comments).unwrap_or(DUMMY_SP);
-                queued_comments.clear();
-
                 let lbl = lbl.map(|l| l.pretty_print());
                 let e = match exit_style {
                     ExitStyle::Break => mk().break_expr(lbl),
                     ExitStyle::Continue => mk().continue_expr(lbl),
                 };
 
-                output.push(mk().span(s).semi_stmt(e));
+                mk().span(span).semi_stmt(e)
             }
-        }
+        };
+
+        (vec![stmt], ast.span)
     }
 }
 
diff --git a/c2rust-transpile/src/diagnostics.rs b/c2rust-transpile/src/diagnostics.rs
index e66f097b1f..57d9cba028 100644
--- a/c2rust-transpile/src/diagnostics.rs
+++ b/c2rust-transpile/src/diagnostics.rs
@@ -8,7 +8,7 @@ use std::io;
 use std::str::FromStr;
 use std::sync::Arc;
 
-use crate::c_ast::DisplaySrcLoc;
+use crate::c_ast::DisplaySrcSpan;
 use c2rust_ast_exporter::get_clang_major_version;
 
 const DEFAULT_WARNINGS: &[Diagnostic] = &[];
@@ -20,6 +20,7 @@ pub enum Diagnostic {
     Comments,
 }
 
+#[allow(unused_macros)]
 macro_rules! diag {
     ($type:path, $($arg:tt)*) => (warn!(target: &$type.to_string(), $($arg)*))
 }
@@ -68,7 +69,7 @@ pub fn init(mut enabled_warnings: HashSet<Diagnostic>, log_level: log::LevelFilt
 
 #[derive(Debug, Clone)]
 pub struct TranslationError {
-    loc: Vec<DisplaySrcLoc>,
+    loc: Vec<DisplaySrcSpan>,
     inner: Arc<Context<TranslationErrorKind>>,
 }
 
@@ -148,7 +149,7 @@ impl TranslationError {
         self.inner.get_context().clone()
     }
 
-    pub fn new(loc: Option<DisplaySrcLoc>, inner: Context<TranslationErrorKind>) -> Self {
+    pub fn new(loc: Option<DisplaySrcSpan>, inner: Context<TranslationErrorKind>) -> Self {
         let mut loc_stack = vec![];
         if let Some(loc) = loc {
             loc_stack.push(loc.clone());
@@ -166,7 +167,7 @@ impl TranslationError {
         }
     }
 
-    pub fn add_loc(mut self, loc: Option<DisplaySrcLoc>) -> Self {
+    pub fn add_loc(mut self, loc: Option<DisplaySrcSpan>) -> Self {
         if let Some(loc) = loc {
             self.loc.push(loc);
         }
diff --git a/c2rust-transpile/src/lib.rs b/c2rust-transpile/src/lib.rs
index 0897f6f78a..14d882a2c7 100644
--- a/c2rust-transpile/src/lib.rs
+++ b/c2rust-transpile/src/lib.rs
@@ -1,5 +1,6 @@
 #![feature(rustc_private)]
 #![feature(label_break_value)]
+#![feature(box_patterns)]
 
 extern crate colored;
 extern crate dtoa;
diff --git a/c2rust-transpile/src/rust_ast/comment_store.rs b/c2rust-transpile/src/rust_ast/comment_store.rs
index c10b9f259f..a8934767a6 100644
--- a/c2rust-transpile/src/rust_ast/comment_store.rs
+++ b/c2rust-transpile/src/rust_ast/comment_store.rs
@@ -22,67 +22,126 @@
 //!   let updated_module: Mod = trav.traverse_mod(module);
 //!   let updated_cmmt_store = trav.into_comment_store();
 //! ```
+//!
+//! Comments can currently be attached and printed in the following positions
+//! (see pprust.rs for current details):
+//!
+//! Before the following AST elements:
+//! - Lit
+//! - Attribute
+//! - Ty
+//! - ForeignItem
+//! - Item
+//! - Variant
+//! - Field
+//! - TraitItem
+//! - ImplItem
+//! - Stmt
+//! - Block
+//! - Path
+//! - Arm
+//!
+//! Trailing comments can be printed after the following elements hi pos, but on
+//! the same line:
+//! - Stmt
+//! - Comma separated Expr (struct initializer, tuples literals, etc.)
+//!
+//! Before the close of a Block
 
-use crate::rust_ast::traverse;
+use crate::rust_ast::{pos_to_span, traverse};
 use itertools::Itertools;
+use smallvec::{smallvec, SmallVec};
 use std::collections::BTreeMap;
 use syntax::ast::*;
 use syntax::parse::lexer::comments;
-use syntax_pos::hygiene::SyntaxContext;
-use syntax_pos::{BytePos, Span, DUMMY_SP};
+use syntax_pos::{BytePos, Span};
 
 pub struct CommentStore {
-    /// The `Span` keys do _not_ correspond to the comment position. Instead, they refer to the
-    /// `Span` of whatever is associated with the comment.
-    output_comments: BTreeMap<Span, comments::Comment>,
+    /// The `BytePos` keys do _not_ correspond to the comment position. Instead, they refer to the
+    /// `BytePos` of whatever is associated with the comment.
+    output_comments: BTreeMap<BytePos, SmallVec<[comments::Comment; 1]>>,
 
     /// Monotonically increasing source of new byte positions.
-    span_source: u32,
+    current_position: u32,
 }
 
 impl CommentStore {
     pub fn new() -> Self {
         CommentStore {
             output_comments: BTreeMap::new(),
-            span_source: 0,
+            current_position: 0,
         }
     }
 
     pub fn into_comment_traverser(self) -> CommentTraverser {
         CommentTraverser {
             old_comments: self.output_comments,
+            old_to_new_pos: BTreeMap::new(),
             store: CommentStore::new(),
         }
     }
 
     /// Convert the comment context into the accumulated (and ordered) `libsyntax` comments.
     pub fn into_comments(self) -> Vec<comments::Comment> {
-        self.output_comments.into_iter().map(|(_, v)| v).collect()
+        self.output_comments.into_iter().map(|(_, v)| v).flatten().collect()
+    }
+
+    /// Add comments at the specified position, then return the `BytePos` that
+    /// should be given to something we want associated with this comment. If
+    /// `pos` is None, or a comment is not found in the given position, use the
+    /// current position instead.
+    fn insert_comments(&mut self, mut new_comments: SmallVec<[comments::Comment; 1]>, pos: Option<BytePos>) -> BytePos {
+        if let Some(pos) = pos {
+            if let Some(comments) = self.output_comments.get_mut(&pos) {
+                comments.extend(new_comments);
+                return pos;
+            }
+        }
+
+        // This line is not necessary. All it does is prevent the confusing
+        // situation where comments have exactly the same position as some AST
+        // node to which they are _not_ related.
+        self.current_position += 1;
+
+        // The position of isolated comments have to be LESS than the span of
+        // the AST node it annotates.
+        for cmmt in &mut new_comments {
+            if let comments::CommentStyle::Isolated = cmmt.style {
+                cmmt.pos = BytePos(self.current_position);
+                self.current_position += 1;
+            }
+        }
+
+        let new_pos = BytePos(self.current_position);
+
+        // The position of trailing comments have to be GREATER than the span of
+        // the AST node it follows.
+        for cmmt in &mut new_comments {
+            if let comments::CommentStyle::Trailing = cmmt.style {
+                self.current_position += 1;
+                cmmt.pos = BytePos(self.current_position);
+            }
+        }
+
+        self.output_comments.insert(new_pos, new_comments);
+        new_pos
     }
 
-    /// Add a `Comment` at the current position, then return the `Span` that should be given to
-    /// something we want associated with this comment.
-    pub fn add_comment(&mut self, mut cmmt: comments::Comment) -> Span {
-        // This line is not necessary. All it does is prevent the confusing situation where comments
-        // have exactly the same position as some AST node to which they are _not_ related.
-        self.span_source += 1;
-
-        // The position of the comment has to be LESS than the span of the AST node it annotates.
-        cmmt.pos = BytePos(self.span_source);
-        self.span_source += 1;
-        let sp = Span::new(
-            BytePos(self.span_source),
-            BytePos(self.span_source),
-            SyntaxContext::empty(),
-        );
-
-        self.output_comments.insert(sp, cmmt);
-        sp
+    /// Add an isolated comment at the current position, then return the `Span`
+    /// that should be given to something we want associated with this comment.
+    pub fn add_comments(&mut self, lines: &[String]) -> Option<BytePos> {
+        self.extend_existing_comments(lines, None, comments::CommentStyle::Isolated)
     }
 
-    /// Add a comment at the current position, then return the `Span` that should be given to
-    /// something we want associated with this comment.
-    pub fn add_comment_lines(&mut self, lines: &[String]) -> Option<Span> {
+    /// Add a comment at the specified position, then return the `BytePos` that
+    /// should be given to something we want associated with this comment. If
+    /// pos is None, use the current position.
+    pub fn extend_existing_comments(
+        &mut self,
+        lines: &[String],
+        pos: Option<BytePos>,
+        style: comments::CommentStyle,
+    ) -> Option<BytePos> {
         fn translate_comment(comment: &String) -> String {
             comment
                 .lines()
@@ -105,25 +164,67 @@ impl CommentStore {
         if lines.is_empty() {
             None
         } else {
-            Some(self.add_comment(comments::Comment {
-                style: comments::CommentStyle::Isolated,
+            let new_comment = comments::Comment {
+                style,
                 lines: lines,
                 pos: BytePos(0), // overwritten in `add_comment`
-            }))
+            };
+            Some(self.insert_comments(smallvec![new_comment], pos))
         }
     }
+
+    /// Move comments associated with `old` to `new`.
+    pub fn move_comments(&mut self, old: BytePos, new: BytePos) {
+        if old == new {
+            return;
+        }
+        if let Some(comments) = self.output_comments.remove(&old) {
+            self.output_comments.get_mut(&new).unwrap().extend(comments);
+        }
+    }
+
+    /// Move any comments attached to the end of `span` to its beginning and
+    /// return a new span for those comments.
+    pub fn move_comments_to_begin(&mut self, span: Span) -> Span {
+        let span = if span.lo() != span.hi() {
+            if span.lo() == BytePos(0) {
+                span.shrink_to_hi()
+            } else {
+                let new_comments = self.output_comments.remove(&span.hi())
+                    .unwrap_or_else(|| panic!("Expected comments attached to the high end of span {:?}", span));
+                self.output_comments.get_mut(&span.lo()).unwrap().extend(new_comments);
+                span.shrink_to_lo()
+            }
+        } else {
+            span
+        };
+
+        // All comments attached to this span should become isolated.
+        if let Some(comments) = self.output_comments.get_mut(&span.lo()) {
+            for comment in comments {
+                comment.style = comments::CommentStyle::Isolated;
+            }
+        }
+
+        span
+    }
 }
 
 pub struct CommentTraverser {
-    old_comments: BTreeMap<Span, comments::Comment>,
+    old_comments: BTreeMap<BytePos, SmallVec<[comments::Comment; 1]>>,
+    old_to_new_pos: BTreeMap<BytePos, BytePos>,
     store: CommentStore,
 }
 impl CommentTraverser {
-    fn reinsert_comment_at(&mut self, sp: Span) -> Span {
-        if let Some(cmmt) = self.old_comments.remove(&sp) {
-            self.store.add_comment(cmmt)
+    fn reinsert_comment_at(&mut self, sp: BytePos) -> Option<BytePos> {
+        if let Some(cmmts) = self.old_comments.remove(&sp) {
+            let new_pos = self.store.insert_comments(cmmts, None);
+            self.old_to_new_pos.insert(sp, new_pos);
+            Some(new_pos)
+        } else if let Some(new_pos) = self.old_to_new_pos.get(&sp) {
+            Some(*new_pos)
         } else {
-            DUMMY_SP
+            None
         }
     }
 
@@ -134,49 +235,34 @@ impl CommentTraverser {
     }
 }
 
-impl traverse::Traversal for CommentTraverser {
-    fn traverse_stmt(&mut self, mut s: Stmt) -> Stmt {
-        s.span = self.reinsert_comment_at(s.span);
-        traverse::traverse_stmt_def(self, s)
-    }
-
-    fn traverse_expr(&mut self, mut e: Expr) -> Expr {
-        e.span = self.reinsert_comment_at(e.span);
-        traverse::traverse_expr_def(self, e)
-    }
-
-    fn traverse_trait_item(&mut self, mut ti: TraitItem) -> TraitItem {
-        ti.span = self.reinsert_comment_at(ti.span);
-        traverse::traverse_trait_item_def(self, ti)
-    }
-
-    fn traverse_impl_item(&mut self, mut ii: ImplItem) -> ImplItem {
-        ii.span = self.reinsert_comment_at(ii.span);
-        traverse::traverse_impl_item_def(self, ii)
-    }
-
-    fn traverse_block(&mut self, mut b: Block) -> Block {
-        b.span = self.reinsert_comment_at(b.span);
-        traverse::traverse_block_def(self, b)
-    }
-
-    fn traverse_local(&mut self, mut l: Local) -> Local {
-        l.span = self.reinsert_comment_at(l.span);
-        traverse::traverse_local_def(self, l)
-    }
-
-    fn traverse_field(&mut self, mut f: Field) -> Field {
-        f.span = self.reinsert_comment_at(f.span);
-        traverse::traverse_field_def(self, f)
-    }
+macro_rules! reinsert_and_traverse {
+    ($fn:ident, $ty:ty, $traverse:path) => {
+        fn $fn(&mut self, mut x: $ty) -> $ty {
+            let orig = x.span.data();
+            x.span = pos_to_span(self.reinsert_comment_at(orig.lo).unwrap_or(BytePos(0)));
+            x = $traverse(self, x);
+            if orig.lo != orig.hi {
+                if let Some(new_hi) = self.reinsert_comment_at(orig.hi) {
+                    x.span = x.span.with_hi(new_hi);
+                }
+            }
+            x
+        }
+    };
+}
 
-    fn traverse_item(&mut self, mut i: Item) -> Item {
-        i.span = self.reinsert_comment_at(i.span);
-        traverse::traverse_item_def(self, i)
-    }
+impl traverse::Traversal for CommentTraverser {
+    reinsert_and_traverse!(traverse_stmt, Stmt, traverse::traverse_stmt_def);
+    reinsert_and_traverse!(traverse_expr, Expr, traverse::traverse_expr_def);
+    reinsert_and_traverse!(traverse_trait_item, TraitItem, traverse::traverse_trait_item_def);
+    reinsert_and_traverse!(traverse_impl_item, ImplItem, traverse::traverse_impl_item_def);
+    reinsert_and_traverse!(traverse_block, Block, traverse::traverse_block_def);
+    reinsert_and_traverse!(traverse_local, Local, traverse::traverse_local_def);
+    reinsert_and_traverse!(traverse_field, Field, traverse::traverse_field_def);
+    reinsert_and_traverse!(traverse_item, Item, traverse::traverse_item_def);
 
     fn traverse_foreign_item(&mut self, mut i: ForeignItem) -> ForeignItem {
-        i.span = self.reinsert_comment_at(i.span);
+        i.span = pos_to_span(self.reinsert_comment_at(i.span.lo()).unwrap_or(BytePos(0)));
         i
     }
 }
diff --git a/c2rust-transpile/src/rust_ast/mod.rs b/c2rust-transpile/src/rust_ast/mod.rs
index 5aedc08fa5..56ab94d290 100644
--- a/c2rust-transpile/src/rust_ast/mod.rs
+++ b/c2rust-transpile/src/rust_ast/mod.rs
@@ -1,3 +1,11 @@
 pub mod comment_store;
 pub mod item_store;
 pub mod traverse;
+
+use syntax_pos::{BytePos, Span};
+use syntax_pos::hygiene::SyntaxContext;
+
+/// Make a new span at `pos`
+pub fn pos_to_span(pos: BytePos) -> Span {
+    Span::new(pos, pos, SyntaxContext::empty())
+}
diff --git a/c2rust-transpile/src/translator/comments.rs b/c2rust-transpile/src/translator/comments.rs
new file mode 100644
index 0000000000..e1508a12cf
--- /dev/null
+++ b/c2rust-transpile/src/translator/comments.rs
@@ -0,0 +1,167 @@
+use std::collections::{HashMap, HashSet};
+use syntax::parse::lexer::comments::CommentStyle;
+use syntax::source_map::{DUMMY_SP, Span};
+use crate::c_ast::{CDeclId, CDeclKind, CommentContext, SrcLoc, TypedAstContext};
+use crate::c_ast::iterators::{NodeVisitor, SomeId};
+use crate::rust_ast::pos_to_span;
+use crate::rust_ast::comment_store::CommentStore;
+use super::Translation;
+
+struct CommentLocator<'c> {
+    ast_context: &'c TypedAstContext,
+    comment_context: &'c CommentContext,
+    comment_store: &'c mut CommentStore,
+    spans: &'c mut HashMap<SomeId, Span>,
+    top_decls: &'c HashSet<CDeclId>,
+    last_id: Option<SomeId>,
+}
+
+impl<'c> CommentLocator<'c> {
+    /// Check for comments starting on the same line but after the end of the
+    /// last node and before the end of the current node.
+    fn check_last_for_trailing(&mut self, cur_loc: SrcLoc) {
+        let last_id = match self.last_id {
+            // We can only attach trailing comments to the end of statements
+            // currently. The pretty-printer only supports trailing comments on
+            // statements and comma-separated exprs, but we don't support
+            // comments after comma-separated exprs yet.
+            Some(SomeId::Stmt(id)) => SomeId::Stmt(id),
+            _ => return,
+        };
+        if let Some(last_loc) = self.ast_context.get_src_loc(last_id) {
+            // TODO: handle Mixed comments (code before and after the
+            // comment on the same line
+            if cur_loc.line == last_loc.end_line {
+                return;
+            }
+
+            while let Some(comment) = self.comment_context
+                .peek_next_comment_on_line(last_loc.end(), &self.ast_context)
+            {
+                if comment.loc.unwrap().end() < cur_loc {
+                    let existing_pos = self.spans.get(&last_id).map(|span| span.lo());
+                    if let Some(pos) = self.comment_store.extend_existing_comments(
+                        &[comment.kind.clone()],
+                        existing_pos,
+                        CommentStyle::Trailing,
+                    ) {
+                        debug!("Attaching comment {:?} to end of line at pos {:?}", comment.kind, pos);
+                        // Add the span if we haven't already
+                        self.spans.entry(last_id).or_insert_with(|| pos_to_span(pos));
+                    }
+                    let file = self.ast_context.file_id(&comment)
+                        .expect("All comments must have a source location");
+                    self.comment_context.advance_comment(file);
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+impl<'c> NodeVisitor for CommentLocator<'c> {
+    fn pre(&mut self, mut id: SomeId) -> bool {
+        // Don't traverse into unvisited top-level decls, we should visit those
+        // in sorted order.
+        if let SomeId::Decl(id) = id {
+            if self.top_decls.contains(&id) {
+                return false;
+            }
+        }
+
+        if let Some(loc) = self.ast_context.get_src_loc(id) {
+            // Check if we have a comment before this node that we need to
+            // attach to the end of the last node.
+            self.check_last_for_trailing(loc.begin());
+
+            let comments = self.comment_context
+                .get_comments_before(loc.begin(), &self.ast_context);
+            if let SomeId::Decl(decl_id) = id {
+                let decl_kind = &self.ast_context[decl_id].kind;
+                if let CDeclKind::NonCanonicalDecl { canonical_decl } = decl_kind {
+                    // Attach non-canonical decl comments to their canonical
+                    // declaration
+                    id = SomeId::Decl(*canonical_decl);
+                }
+            }
+            if let Some(existing) = self.spans.get(&id) {
+                let new_pos = self.comment_store.extend_existing_comments(
+                    &comments,
+                    Some(existing.lo()),
+                    CommentStyle::Isolated,
+                );
+                debug!("Attaching more comments {:?} to id {:?} at pos {:?}", comments, id, new_pos);
+            } else if let Some(pos) = self.comment_store.add_comments(&comments) {
+                debug!("Attaching comments {:?} to id {:?} at pos {:?}", comments, id, pos);
+                let span = pos_to_span(pos);
+                self.spans.insert(id, span);
+            }
+        }
+
+        // Don't traverse into macro object replacement expressions, as they are
+        // in other places.
+        if let SomeId::Decl(id) = id {
+            if let CDeclKind::MacroObject{..} = self.ast_context[id].kind {
+                return false;
+            }
+        }
+
+        true
+    }
+
+    fn post(&mut self, id: SomeId) {
+        // Don't attach comments to the end of unvisited top-level decls, we'll
+        // visit them later.
+        if let SomeId::Decl(id) = id {
+            if self.top_decls.contains(&id) {
+                return;
+            }
+        }
+        if let Some(loc) = self.ast_context.get_src_loc(id) {
+            let comments = self.comment_context
+                .get_comments_before(loc.end(), &self.ast_context);
+            if let Some(pos) = self.comment_store.add_comments(&comments) {
+                debug!("Attaching comments {:?} to end of id {:?} at pos {:?}", comments, id, pos);
+                let span = self.spans.entry(id)
+                    .or_insert(DUMMY_SP);
+                *span = span.with_hi(pos);
+            }
+
+            // Check if we have a comment before the end of this node that we
+            // need to attach to the end of the last node.
+            self.check_last_for_trailing(loc.end());
+        }
+
+        self.last_id = Some(id);
+    }
+}
+
+impl<'c> Translation<'c> {
+    /// Create spans for each C AST node that has a comment attached to it.
+    pub fn locate_comments(&mut self) {
+        let mut top_decls: HashSet<CDeclId> = self.ast_context
+            .c_decls_top
+            .iter()
+            .copied()
+            .collect();
+        let mut spans: HashMap<SomeId, Span> = HashMap::new();
+        for decl_id in &self.ast_context.c_decls_top {
+            top_decls.remove(decl_id);
+            let mut visitor = CommentLocator {
+                ast_context: &self.ast_context,
+                comment_context: &self.comment_context,
+                comment_store: &mut *self.comment_store.borrow_mut(),
+                spans: &mut spans,
+                top_decls: &top_decls,
+                last_id: None,
+            };
+            visitor.visit_tree(&self.ast_context, SomeId::Decl(*decl_id));
+        }
+        self.spans = spans;
+    }
+
+    pub fn get_span(&self, id: SomeId) -> Option<Span> {
+        self.spans.get(&id).copied()
+    }
+}
diff --git a/c2rust-transpile/src/translator/mod.rs b/c2rust-transpile/src/translator/mod.rs
index 89b21d8f35..97155183b3 100644
--- a/c2rust-transpile/src/translator/mod.rs
+++ b/c2rust-transpile/src/translator/mod.rs
@@ -1,4 +1,5 @@
 use std::cell::RefCell;
+use std::collections::HashMap;
 use std::ops::Index;
 use std::path::{self, PathBuf};
 use std::{char, io};
@@ -11,15 +12,17 @@ use indexmap::{IndexMap, IndexSet};
 use rustc_data_structures::sync::Lrc;
 use syntax::attr;
 use syntax::ast::*;
+use syntax::parse::lexer::comments::CommentStyle;
 use syntax::parse::token::{self, DelimToken, Nonterminal};
-use syntax::print::pprust::*;
+use syntax::print::pprust::{self, PrintState};
 use syntax::ptr::*;
-use syntax::source_map::dummy_spanned;
+use syntax::source_map::{dummy_spanned, FilePathMapping, SourceMap};
 use syntax::tokenstream::{TokenStream, TokenTree};
 use syntax::{ast, with_globals};
-use syntax_pos::{Span, DUMMY_SP};
+use syntax_pos::{FileName, Span, DUMMY_SP};
 use syntax_pos::edition::Edition;
 
+use crate::rust_ast::pos_to_span;
 use crate::rust_ast::comment_store::CommentStore;
 use crate::rust_ast::item_store::ItemStore;
 use crate::rust_ast::traverse::Traversal;
@@ -38,6 +41,7 @@ use c2rust_ast_exporter::clang_ast::LRValue;
 mod assembly;
 mod bitfields;
 mod builtins;
+mod comments;
 mod literals;
 mod main_function;
 mod named_references;
@@ -238,6 +242,8 @@ pub struct Translation<'c> {
     pub comment_context: CommentContext, // Incoming comments
     pub comment_store: RefCell<CommentStore>,     // Outgoing comments
 
+    spans: HashMap<SomeId, Span>,
+
     // Items indexed by file id of the source
     items: RefCell<IndexMap<FileId, ItemStore>>,
 
@@ -472,14 +478,16 @@ pub fn translate(
 
     t.extern_crates.borrow_mut().insert("libc");
 
-    // Headers often pull in declarations that are unused;
-    // we simplify the translator output by omitting those.
-    t.ast_context.prune_unused_decls();
-
     // Sort the top-level declarations by file and source location so that we
     // preserve the ordering of all declarations in each file.
     t.ast_context.sort_top_decls();
 
+    t.locate_comments();
+
+    // Headers often pull in declarations that are unused;
+    // we simplify the translator output by omitting those.
+    t.ast_context.prune_unused_decls();
+
     enum Name<'a> {
         VarName(&'a str),
         TypeName(&'a str),
@@ -737,8 +745,6 @@ pub fn translate(
         let translation = to_string(|s| {
             print_header(s, &t)?;
 
-            // Re-order comments
-            let mut traverser = t.comment_store.into_inner().into_comment_traverser();
             let mut mod_items: Vec<P<Item>> = Vec::new();
 
             // Keep track of new uses we need while building header submodules
@@ -747,19 +753,32 @@ pub fn translate(
             // Header Reorganization: Submodule Item Stores
             for (file_id, ref mut mod_item_store) in t.items.borrow_mut().iter_mut() {
                 if *file_id != t.main_file {
-                    mod_items.push(make_submodule(
+                    let mut submodule = make_submodule(
                         &t.ast_context,
                         mod_item_store,
                         *file_id,
                         &mut new_uses,
                         &t.mod_names,
-                    ));
+                    );
+                    let comments = t.comment_context.get_remaining_comments(*file_id);
+                    submodule.span = match t
+                        .comment_store
+                        .borrow_mut()
+                        .add_comments(&comments)
+                    {
+                        Some(pos) => submodule.span.with_hi(pos),
+                        None => submodule.span,
+                    };
+                    mod_items.push(submodule);
                 }
             }
 
             // Main file item store
             let (items, foreign_items, uses) = t.items.borrow_mut()[&t.main_file].drain();
 
+            // Re-order comments
+            let mut traverser = t.comment_store.into_inner().into_comment_traverser();
+
             // Add a comment mapping span to each node that should have a
             // comment printed before it. The pretty printer picks up these
             // spans and uses them to decide when to emit comments.
@@ -776,9 +795,12 @@ pub fn translate(
                 .map(|p_i| p_i.map(|i| traverser.traverse_item(i)))
                 .collect();
 
+            let mut reordered_comment_store = traverser.into_comment_store();
+            let remaining_comments = t.comment_context.get_remaining_comments(t.main_file);
+            reordered_comment_store.add_comments(&remaining_comments);
             s.comments()
                 .get_or_insert(vec![])
-                .extend(traverser.into_comment_store().into_comments());
+                .extend(reordered_comment_store.into_comments());
 
             for mod_item in mod_items {
                 s.print_item(&*mod_item)?;
@@ -807,12 +829,45 @@ pub fn translate(
                 s.print_item(&*x)?;
             }
 
+            s.print_remaining_comments()?;
+
             Ok(())
         });
         (translation, pragmas, crates)
     })
 }
 
+/// Same as pprust::to_string, but initializes the printer with an empty
+/// SourceMap, which is necessary to get the printer to print trailing comments
+/// on the same line.
+fn to_string<F>(f: F) -> String where
+    F: FnOnce(&mut pprust::State<'_>) -> io::Result<()>,
+{
+    let mut wr = Vec::new();
+    {
+        let ann = pprust::NoAnn;
+
+        // We need a dummy SourceMap with a dummy file so that pprust can try to
+        // look up source line numbers for Spans. This is needed to be able to
+        // print trailing comments after exprs/stmts/etc. on the same line. The
+        // SourceMap will think that all Spans are invalid, but will return line
+        // 0 for all of them.
+        let sm = SourceMap::new(FilePathMapping::empty());
+        sm.new_source_file(FileName::Custom("<dummy>".to_string()), " ".to_string());
+
+        let mut printer = pprust::State::new(
+            &sm,
+            Box::new(&mut wr),
+            &ann,
+            None,
+            false,
+        );
+        f(&mut printer).unwrap();
+        printer.s.eof().unwrap();
+    }
+    String::from_utf8(wr).unwrap()
+}
+
 fn make_submodule(
     ast_context: &TypedAstContext,
     item_store: &mut ItemStore,
@@ -862,7 +917,7 @@ fn make_submodule(
 }
 
 /// Pretty-print the leading pragmas and extern crate declarations
-fn print_header(s: &mut State, t: &Translation) -> io::Result<()> {
+fn print_header(s: &mut pprust::State, t: &Translation) -> io::Result<()> {
     if t.tcfg.emit_modules {
         s.print_item(&mk().use_simple_item(vec!["libc"], None as Option<Ident>))?;
     } else {
@@ -1023,6 +1078,7 @@ impl<'c> Translation<'c> {
             macro_types: RefCell::new(IndexMap::new()),
             comment_context,
             comment_store: RefCell::new(CommentStore::new()),
+            spans: HashMap::new(),
             sectioned_static_initializers: RefCell::new(Vec::new()),
             items: RefCell::new(items),
             mod_names: RefCell::new(IndexMap::new()),
@@ -1316,18 +1372,12 @@ impl<'c> Translation<'c> {
         ctx: ExprContext,
         decl_id: CDeclId,
     ) -> Result<ConvertedDecl, TranslationError> {
-        let mut s = self
-            .comment_context
-            .get_decl_comment(decl_id)
-            .and_then(|decl_cmt| self.comment_store.borrow_mut().add_comment_lines(decl_cmt))
-            .unwrap_or(DUMMY_SP);
-
         let decl = self
             .ast_context
             .get_decl(&decl_id)
             .ok_or_else(|| format_err!("Missing decl {:?}", decl_id))?;
 
-        let _src_loc = &decl.loc;
+        let mut s = self.get_span(SomeId::Decl(decl_id)).unwrap_or(DUMMY_SP);
 
         match decl.kind {
             CDeclKind::Struct { fields: None, .. }
@@ -1342,6 +1392,7 @@ impl<'c> Translation<'c> {
                     .borrow()
                     .resolve_decl_name(decl_id)
                     .unwrap();
+
                 let extern_item = mk().span(s).pub_().ty_foreign_item(name);
                 Ok(ConvertedDecl::ForeignItem(extern_item))
             }
@@ -1618,14 +1669,14 @@ impl<'c> Translation<'c> {
                 let is_main = self.ast_context.c_main == Some(decl_id);
 
                 let converted_function = self.convert_function(
-                    ctx, s, is_global, is_inline, is_main, is_var, is_extern, new_name, name,
-                    &args, ret, body, attrs,
+                    ctx, s, is_global, is_inline, is_main, is_var, is_extern,
+                    new_name, name, &args, ret, body, attrs,
                 );
 
                 converted_function.or_else(|e| match self.tcfg.replace_unsupported_decls {
                     ReplaceMode::Extern if body.is_none() => self.convert_function(
-                        ctx, s, is_global, false, is_main, is_var, is_extern, new_name, name,
-                        &args, ret, None, attrs,
+                        ctx, s, is_global, false, is_main, is_var, is_extern,
+                        new_name, name, &args, ret, None, attrs,
                     ),
                     _ => Err(e),
                 })
@@ -1739,11 +1790,20 @@ impl<'c> Translation<'c> {
                     let mut init = init?.to_expr();
 
                     let comment = String::from("// Initialized in run_static_initializers");
-                    // REVIEW: We might want to add the comment to the original span comments
+                    let comment_pos = if s.is_dummy() {
+                        None
+                    } else {
+                        Some(s.lo())
+                    };
                     s = self
                         .comment_store
                         .borrow_mut()
-                        .add_comment_lines(&[comment])
+                        .extend_existing_comments(
+                            &[comment],
+                            comment_pos,
+                            CommentStyle::Isolated,
+                        )
+                        .map(pos_to_span)
                         .unwrap_or(s);
 
                     self.add_static_initializer_to_section(new_name, typ, &mut init)?;
@@ -2024,7 +2084,10 @@ impl<'c> Translation<'c> {
                     _ => panic!("function body expects to be a compound statement"),
                 };
                 body_stmts.append(&mut self.convert_function_body(ctx, name, body_ids, ret)?);
-                let block = stmts_block(body_stmts);
+                let mut block = stmts_block(body_stmts);
+                if let Some(span) = self.get_span(SomeId::Stmt(body)) {
+                    block.span = span;
+                }
 
                 // Only add linkage attributes if the function is `extern`
                 let mut mk_ = if is_main {
@@ -2334,7 +2397,8 @@ impl<'c> Translation<'c> {
                     let span = self
                         .comment_store
                         .borrow_mut()
-                        .add_comment_lines(&[comment])
+                        .add_comments(&[comment])
+                        .map(pos_to_span)
                         .unwrap_or(DUMMY_SP);
                     let static_item =
                         mk().span(span)
@@ -4305,7 +4369,7 @@ impl<'c> Translation<'c> {
         let decl_file_id = self.ast_context.file_id(decl);
 
         if self.tcfg.reorganize_definitions {
-            add_src_loc_attr(&mut item.attrs, &decl.loc);
+            add_src_loc_attr(&mut item.attrs, &decl.loc.as_ref().map(|x| x.begin()));
             let mut item_stores = self.items.borrow_mut();
             let items = item_stores
                 .entry(decl_file_id.unwrap())
@@ -4323,7 +4387,7 @@ impl<'c> Translation<'c> {
         let decl_file_id = self.ast_context.file_id(decl);
 
         if self.tcfg.reorganize_definitions {
-            add_src_loc_attr(&mut item.attrs, &decl.loc);
+            add_src_loc_attr(&mut item.attrs, &decl.loc.as_ref().map(|x| x.begin()));
             let mut items = self.items.borrow_mut();
             let mod_block_items = items
                 .entry(decl_file_id.unwrap())
diff --git a/tests/comments/src/comments.c b/tests/comments/src/comments.c
index 0801ba8f2e..eea9f44f11 100644
--- a/tests/comments/src/comments.c
+++ b/tests/comments/src/comments.c
@@ -13,7 +13,7 @@ int a_function() {
 /* and another */
 
 /* one more */
-#define CONSTANT 0
+#define CONSTANT 0 /* comment at the end of define */
 
 /* something in between */
 
@@ -23,9 +23,34 @@ int test_fn() {
   /* comment in a function */
 
   /* another */
+  int x = CONSTANT; /* at end of statement line */
+
+  /* comment on empty stmt */
+  (void)x; /* trailing comment on empty stmt */
+
+  /* before while */
+  while (x < 5) { /* trailing block begin */
+    /* in while */
+    x++;
+    /* end of while */
+  }
+
+  if (x > 100) {
+    /* in an if */
+    x = 10;
+    /* end of if */
+  } else if (x > 200) {
+    /* in else if */
+    x = 12;
+    /* end of else if */
+  } else {
+    /* in else */
+    x = x;
+    /* end of else */
+  }
 
   /* before a statement */
-  return CONSTANT + CONSTANT1;
+  return x + CONSTANT1;
 
   /* after all statements */
 }
diff --git a/tests/comments/src/comments.h b/tests/comments/src/comments.h
index 07118ac396..e2cd3fd014 100644
--- a/tests/comments/src/comments.h
+++ b/tests/comments/src/comments.h
@@ -2,6 +2,9 @@
 
 /* another header comment */
 
+/* comment on the decl of test_fn */
+int test_fn();
+
 /* a comment on a declaration */
 int a_function();
 
diff --git a/tests/comments/src/test_comments.rs b/tests/comments/src/test_comments.rs
index bb249a8d29..ca02492dd7 100644
--- a/tests/comments/src/test_comments.rs
+++ b/tests/comments/src/test_comments.rs
@@ -2,5 +2,5 @@ use comments::{CONSTANT, CONSTANT1, rust_test_fn};
 
 pub fn test_comments() {
     let val = unsafe { rust_test_fn() };
-    assert_eq!(CONSTANT+CONSTANT1, val);
+    assert_eq!(6, val);
 }
diff --git a/tests/gotos/src/idiomatic_nested_loops.c b/tests/gotos/src/idiomatic_nested_loops.c
index 77d8274eed..9afa37c131 100644
--- a/tests/gotos/src/idiomatic_nested_loops.c
+++ b/tests/gotos/src/idiomatic_nested_loops.c
@@ -1,18 +1,31 @@
 // This shoud translate to a straightforward `break` with a loop label 
 int break_multiple(int x) {
+  /* comment1 */
 
     while (x < 5) {
+        /* comment2 */
         while (x < 5) {
+            /* comment3 */
             while (x < 5) {
+                /* comment4 */
                 if (x < 2)
+                    /* comment5 */
                     goto break_outer;
+                /* comment6 */
                 x++;
+                /* comment7 */
             }
+            /* comment8 */
         }
+        /* comment9 */
     }
+    /* comment10 */
 
 break_outer:
+    /* comment11 */
     x += 4;
 
+    /* comment12 */
     return x;
+    /* comment13 */
 }