.setFile(d.getLibraryFile())
            .setSource(d.getSourceFile())
            .setJavadoc(d.getJavadocFile())
            .setScope(new DefaultIdeaDependencyScope(d.getScope()))
            .setExported(d.isExported());

        if (d.getModuleVersion() != null) {
            defaultDependency.setGradleModuleVersion(new DefaultGradleModuleVersion(d.getModuleVersion()));
        }
        return defaultDependency;
    }

  if (!global_tensor.getIsMutable()) {
    return false;
  }
  // An exported global tensor that is not already known to be immutable might
  // be externally mutated.
  if (IsExported(global_tensor)) {
    return false;
  }

  // A global tensor is immutable if the resource analyzer deems it so.
  for (auto& global_tensor_use : global_tensor_uses) {

			// 	p.printf("\n")
			// }
		}

		for i, n := 0, typ.NumField(); i < n; i++ {
			// Exclude non-exported fields because their
			// values cannot be accessed via reflection.
			if name := typ.Field(i).Name; isExported(name) {
				if first {
					p.printf("\n")
					first = false
				}
				p.printf("%s: ", name)
				p.dump(x.Field(i), nil)
				p.printf("\n")
			}
		}

		p.indent--
		p.printf("}")

     */
    String getPath();

    /**
     * Marks this dependency as exported.
     *
     * @return whether this dependency needs to be exported.
     * @since 2.5
     */
    boolean isExported();

        }

        public String getName() {
            return name;
        }

        public char getType() {
            return type;
        }

        public boolean isExported() {
            return exported;
        }

        public String toString() {
            return MoreObjects.toStringHelper(this).add("name", name).add("type", type).add("exported", exported).toString();
        }

     */
    String getPath();

    /**
     * Marks this container as exported.
     *
     * @return whether this container needs to be exported.
     */
    boolean isExported();

    })
}
// end::project-before-merged[]

// tag::module-when-merged[]

idea.module.iml {
    whenMerged(Action<Module> {
        dependencies.forEach {
            (it as ModuleDependency).isExported = true
        }
    })
}
// end::module-when-merged[]

// tag::project-with-xml[]

idea.project.ipr {
    withXml(Action<XmlProvider> {

// IsKeyword returns true for tokens corresponding to keywords;
// it returns false otherwise.
func (tok Token) IsKeyword() bool { return keyword_beg < tok && tok < keyword_end }

// IsExported reports whether name starts with an upper-case letter.
func IsExported(name string) bool {
	ch, _ := utf8.DecodeRuneInString(name)
	return unicode.IsUpper(ch)
}

// IsKeyword reports whether name is a Go keyword, such as "func" or "return".

  void runOnOperation() final;
};

void DedupBoundInputBindingPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!mlir::tf_saved_model::IsExported(func)) return;
  llvm::SmallDenseMap<Attribute, unsigned, 8> unique_bound_inputs;
  llvm::BitVector arg_indices_to_erase(func.getNumArguments());
  for (unsigned i = 0, e = func.getNumArguments(); i < e; i++) {

	setScopePos(pos syntax.Pos)
}

func isExported(name string) bool {
	ch, _ := utf8.DecodeRuneInString(name)
	return unicode.IsUpper(ch)
}

// Id returns name if it is exported, otherwise it
// returns the name qualified with the package path.
func Id(pkg *Package, name string) string {
	if isExported(name) {
		return name
	}
	// unexported names need the package path for differentiation