FM / frontend

/usr/local/lib64/python3.6/site-packages/torch/include/torch/csrc/jit/frontend/

/usr/local/lib64/python3.6/site-packages/torch/include/torch/csrc/jit/frontend

Name	Size	Mode	Actions
builtin_functions.h	254	0644	edit dl rm
canonicalize_modified_loop.h	326	0644	edit dl rm
code_template.h	7057	0644	edit dl rm
concrete_module_type.h	9040	0644	edit dl rm
convert_to_ssa.h	341	0644	edit dl rm
edit_distance.h	268	0644	edit dl rm
error_report.h	1480	0644	edit dl rm
exit_transforms.h	232	0644	edit dl rm
function_schema_parser.h	460	0644	edit dl rm
inline_loop_condition.h	366	0644	edit dl rm
ir_emitter.h	541	0644	edit dl rm
lexer.h	18470	0644	edit dl rm
mini_environment.h	1366	0644	edit dl rm
name_mangler.h	669	0644	edit dl rm
parser.h	688	0644	edit dl rm
parser_constants.h	162	0644	edit dl rm
parse_string_literal.h	2295	0644	edit dl rm
resolver.h	1972	0644	edit dl rm
schema_matching.h	1948	0644	edit dl rm
schema_type_parser.h	977	0644	edit dl rm
script_type_parser.h	1619	0644	edit dl rm
source_range.h	6038	0644	edit dl rm
source_ref.h	1269	0644	edit dl rm
strtod.h	240	0644	edit dl rm
sugared_value.h	26805	0644	edit dl rm
tracer.h	11925	0644	edit dl rm
tree.h	6635	0644	edit dl rm
tree_views.h	35696	0644	edit dl rm
versioned_symbols.h	597	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/torch/csrc/jit/frontend/resolver.h (1972B)

#pragma once

#include <ATen/core/jit_type.h>
#include <ATen/core/qualified_name.h>
#include <torch/csrc/jit/frontend/sugared_value.h>

namespace torch {
namespace jit {

struct Resolver;
using ResolverPtr = std::shared_ptr<Resolver>;

/**
 * class Resolver
 *
 * Represents an "outer environment" in which we an look up names and return
 * a corresponding SugaredValue. This is used during compilation to resolve
 * references to names which are not defined internal to the graph.
 *
 * Example: PythonResolver looks at the enclosing Python scope for `name`.
 *
 * NOTE: When adding methods, keep this an abstract class (i.e. all new methods
 * should be purely virtual). Resist the urge to provide a default
 * implementation; you should explicitly think about how each resolver would
 * handle the method.
 */
struct Resolver {
  virtual ~Resolver() = default;

// Resolve a given name to a SugaredValue. This takes the method `m` that the
  // caller is currently constructing, since we may need to insert nodes into
  // the graph to create a value.
  virtual std::shared_ptr<SugaredValue> resolveValue(
      const std::string& name,
      Function& m,
      const SourceRange& loc) {
    return nullptr;
  }

// Resolve `name` to a TypePtr.
  virtual TypePtr resolveType(const std::string& name, const SourceRange& loc) {
    return nullptr;
  }
};

// A resolver that only understands "torch.foo()" lookups.
struct NativeResolver : public Resolver {
  std::shared_ptr<SugaredValue> resolveValue(
      const std::string& name,
      Function& m,
      const SourceRange& loc) override {
    if (name == "torch") {
      return std::make_shared<BuiltinModule>("aten");
    }
    return nullptr;
  }

TypePtr resolveType(const std::string& name, const SourceRange& loc)
      override {
    return nullptr;
  }
};

inline std::shared_ptr<NativeResolver> nativeResolver() {
  return std::make_shared<NativeResolver>();
}
} // namespace jit
} // namespace torch

#pragma once #include #include #include namespace torch { namespace jit { struct Resolver; using ResolverPtr = std::shared_ptr; /** * class Resolver * * Represents an "outer environment" in which we an look up names and return * a corresponding SugaredValue. This is used during compilation to resolve * references to names which are not defined internal to the graph. * * Example: PythonResolver looks at the enclosing Python scope for `name`. * * NOTE: When adding methods, keep this an abstract class (i.e. all new methods * should be purely virtual). Resist the urge to provide a default * implementation; you should explicitly think about how each resolver would * handle the method. */ struct Resolver { virtual ~Resolver() = default; // Resolve a given name to a SugaredValue. This takes the method `m` that the // caller is currently constructing, since we may need to insert nodes into // the graph to create a value. virtual std::shared_ptr resolveValue( const std::string& name, Function& m, const SourceRange& loc) { return nullptr; } // Resolve `name` to a TypePtr. virtual TypePtr resolveType(const std::string& name, const SourceRange& loc) { return nullptr; } }; // A resolver that only understands "torch.foo()" lookups. struct NativeResolver : public Resolver { std::shared_ptr resolveValue( const std::string& name, Function& m, const SourceRange& loc) override { if (name == "torch") { return std::make_shared("aten"); } return nullptr; } TypePtr resolveType(const std::string& name, const SourceRange& loc) override { return nullptr; } }; inline std::shared_ptr nativeResolver() { return std::make_shared(); } } // namespace jit } // namespace torch