TBD expr public void Include(Expression<Func<T, object>> path)
351132
public void _include(IncludeBuilderBase includes) {
        if (includes == null) {
            return;
        }

        if (includes.documentsToInclude != null) {
            for (String doc : includes.documentsToInclude) {
                documentIncludes.add(doc);
            }
        }

        _includeCounters(includes.alias, includes.countersToIncludeBySourcePath);
    }
350374
public static <F,T> Function<F,T> wrap(Expression<T> projection) {
        Path<?> path = projection.accept(PathExtractor.DEFAULT, null);
        if (path != null) {
            final Evaluator<T> ev = createEvaluator(path.getRoot(), projection);
            return new Function<F,T>() {
                @Override
                public T apply(F input) {
                    return ev.evaluate(input);
                }
            };
        } else {
            throw new IllegalArgumentException("No path in " + projection);
        }
    }
772981
private Object[] compile(String path) {
        List<String> lst;

        lst = Filesystem.SEPARATOR.split(path);
        if (lst.size() == 0) {
            throw new IllegalArgumentException("empty path: " + path);
        }
        if (lst.get(0).equals("")) {
            throw new IllegalArgumentException("absolute path not allowed: " + path);
        }
        if (lst.get(lst.size() - 1).equals("")) {
            throw new IllegalArgumentException(
                "path must not end with separator: " + path);
        }
        return compileTail(lst, 0);
    }
1263958
function include( path, isFromInclude, dot_path ) {
			if(!path){
				return;
			}
			all_paths.push(path)
			if(isNode){
				require(path);
				listenFileChange(path);
				if(isFromInclude){
					fileLoadeManager.iamready(dot_path);
				}
				return;
			}
			if (fm.isConcatinated) {
				fileLoadeManager.iamready(dot_path);
				return;
			}

			if (!docHead) {
				docHead = document.getElementsByTagName("head")[0];
			}

			// isNonfm && fm.holdReady(true);
			var e = document.createElement("script");
			// onerror is not supported by IE so this will throw exception only for
			// non IE browsers.

			if(me.version){
				path += "?v=" + me.version;
			}
			e.onerror = onFileLoadError;
			if(isFromInclude){
				e.onload = function(){
					fileLoadeManager.iamready(dot_path);
					$(document).trigger('jsfm-iamready-'+ path.split("/").pop().replace(".js", ""), [path]);
				};
			}

			e.src = path;
			e.type = "text/javascript";
			docHead.appendChild(e);
		}
65473
function render(expr, traverse, path, state) {
  if (isString(expr)) {
    utils.append(expr, state);
  } else if (Array.isArray(expr)) {
    expr.forEach(function(w) {
      render(w, traverse, path, state);
    });
  } else {
    utils.move(expr.range[0], state);
    traverse(expr, path, state);
    utils.catchup(expr.range[1], state);
  }
}
769081
function include(filePath, extraVars) {
    if(!pathIsAbsolute(filePath)){
      filePath = path.resolve(path.dirname(this.file), filePath);
    }

    var vars = {};
    for(var ii in this.vars){
      vars[ii] = this.vars[ii];
    }
    if(extraVars){
      for(var jj in extraVars){
        vars[jj] = extraVars[jj];
      }
    }
    return render(readFile(filePath, {encoding: 'utf8'}), vars, filePath);
  }
1228460
private void addIncludes(DBHandling handling, FileSet fileSet) throws BuildException
    {
        DirectoryScanner scanner  = fileSet.getDirectoryScanner(getProject());
        String[]         files    = scanner.getIncludedFiles();
        StringBuffer     includes = new StringBuffer();

        for (int idx = 0; idx < files.length; idx++)
        {
            if (idx > 0)
            {
                includes.append(",");
            }
            includes.append(files[idx]);
        }
        try
        {
            handling.addDBDefinitionFiles(fileSet.getDir(getProject()).getAbsolutePath(), includes.toString());
        }
        catch (IOException ex)
        {
            throw new BuildException(ex);
        }
    }
720716
private void parseRelativePathExpr() throws TTXPathException {

        parseStepExpr();

        while (mToken.getType() == TokenType.SLASH || mToken.getType() == TokenType.DESC_STEP) {

            if (is(TokenType.DESC_STEP, true)) {
                final AbsAxis mAxis = new DescendantAxis(getTransaction(), true);

                mPipeBuilder.addStep(mAxis);
            } else {
                // in this case the slash is just a separator
                consume(TokenType.SLASH, true);
            }
            parseStepExpr();
        }

    }
224145
private void parseExprSingle() throws TTXPathException {

        mPipeBuilder.addExpressionSingle();

        final String tContent = mToken.getContent();
        if ("for".equals(tContent)) {
            parseForExpr();
        } else if ("some".equals(tContent) || "every".equals(tContent)) {
            parseQuantifiedExpr();
        } else if ("if".equals(tContent)) {
            parseIfExpr();
        } else {
            parseOrExpr();
        }
    }
89088
@SuppressWarnings("unchecked")
    public static <T> Expression<T> extract(Expression<T> expr) {
        if (expr != null) {
            final Class<?> clazz = expr.getClass();
            if (clazz == PathImpl.class || clazz == PredicateOperation.class || clazz == ConstantImpl.class) {
                return expr;
            } else {
                return (Expression<T>) expr.accept(ExtractorVisitor.DEFAULT, null);
            }
        } else {
            return null;
        }
    }
1127037
def p_expr_include(p):
    ''
    p[0] = ast.Include(p[2], False, lineno=p.lineno(1))
435539
private void parseIntersectExceptExpr() throws TTXPathException {

        parseInstanceOfExpr();

        boolean isIntersect = mToken.getContent().equals("intersect");

        while (is("intersect", true) || is("except", true)) {
            // parse second operand axis

            mPipeBuilder.addExpressionSingle();

            parseInstanceOfExpr();

            mPipeBuilder.addIntExcExpression(getTransaction(), isIntersect);

            isIntersect = mToken.getContent().equals("intersect");
        }

    }
1365619
function parseExpression (exp) {
  exp = exp.trim()
  var res = isSimplePath(exp) && exp.indexOf('[') < 0
    // optimized super simple getter
    ? 'this.' + exp
    // dynamic getter
    : compileGetter(exp)
  return res
}
531286
private void parseAndExpr() throws TTXPathException {

        parseComparisionExpr();

        while (is("and", true)) {

            mPipeBuilder.addExpressionSingle();

            parseComparisionExpr();
            mPipeBuilder.addAndExpression(getTransaction());

        }
    }
1163251
public static <T> String path(TreeDef.Parented<T> treeDef, T node, Function<? super T, String> toString) {
		return path(treeDef, node, toString, "/");
	}
858780
public static Filter<ArchivePath> include(String regexp) {
        return getFilterInstance(IMPL_CLASS_NAME_INCLUDE_REGEXP_PATHS, new Class<?>[] { String.class },
            new Object[] { regexp });
    }
344421
function(topPath) {
            if (
              !topPath.parentPath.isExpressionStatement() &&
              !topPath.parentPath.isSequenceExpression()
            ) {
              return;
            }

            const mutations = [];
            let firstLeft = null;
            let operator = null;
            function visit(path) {
              if (path.isConditionalExpression()) {
                let bail = visit(path.get("consequent"));
                if (bail) {
                  return true;
                }
                bail = visit(path.get("alternate"));
                return bail;
              }

              if (operator == null) {
                operator = path.node.operator;
              } else if (path.node.operator !== operator) {
                return true;
              }

              if (
                !path.isAssignmentExpression() ||
                !(
                  path.get("left").isIdentifier() ||
                  path.get("left").isMemberExpression()
                )
              ) {
                return true;
              }

              const left = path.get("left").node;
              if (firstLeft == null) {
                firstLeft = left;
              } else if (!t.isNodesEquivalent(left, firstLeft)) {
                return true;
              }

              mutations.push(() => path.replaceWith(path.get("right").node));
            }

            const bail = visit(topPath);
            if (bail) {
              return;
            }

            mutations.forEach(f => f());
            topPath.replaceWith(
              t.assignmentExpression(operator, firstLeft, topPath.node)
            );
          }