---

yaml
---
r: 6383
b: refs/heads/master
c: 0e21df4
h: refs/heads/master
i:
  6381: ce065cf
  6379: 7a10412
  6375: 13a625e
  6367: e993b89
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8cf3ca3b55dbab193903a00eb427156365e44c67
+refs/heads/master: 0e21df46106ba80c43295d5f7ca57121baa1ac1e

trunk/src/comp/middle/kind.rs

@@ -3,6 +3,21 @@ import syntax::{visit, ast_util};
 import syntax::ast::*;
 import syntax::codemap::span;
 
+// Kind analysis pass. There are three kinds:
+//
+//  sendable: scalar types, and unique types containing only sendable types
+//  copyable: boxes, objects, closures, and uniques containing copyable types
+//  noncopyable: resources, or unique types containing resources
+//
+// This pass ensures that type parameters are only instantiated with types
+// whose kinds are equal or less general than the way the type parameter was
+// annotated (with the `send` or `copy` keyword).
+//
+// It also verifies that noncopyable kinds are not copied. Sendability is not
+// applied, since none of our language primitives send. Instead, the sending
+// primitives in the stdlib are explicitly annotated to only take sendable
+// types.
+
 fn kind_to_str(k: kind) -> str {
     alt k {
       kind_sendable. { "sendable" }

trunk/src/comp/middle/last_use.rs

@@ -3,6 +3,24 @@ import syntax::ast::*;
 import std::list::{list, nil, cons, tail};
 import std::{vec, list, option};
 
+// Last use analysis pass.
+//
+// Finds the last read of each value stored in a local variable or
+// callee-owned argument (arguments with by-move or by-copy passing
+// style). This is a limited form of liveness analysis, peformed
+// (perhaps foolishly) directly on the AST.
+//
+// The algorithm walks the AST, keeping a set of (def, last_use)
+// pairs. When the function is exited, or the local is overwritten,
+// the current set of last uses is marked with 'true' in a table.
+// Other branches may later overwrite them with 'false' again, since
+// they may find a use coming after them. (Marking an expression as a
+// last use is only done if it has not already been marked with
+// 'false'.)
+//
+// Some complexity is added to deal with joining control flow branches
+// (by `break` or conditionals), and for handling loops.
+
 // Marks expr_paths that are last uses.
 type last_uses = std::map::hashmap<node_id, ()>;