Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "s", "*", "SourceImportAuthor", ")", "GetRemoteName", "(", ")", "string", "{", "if", "s", "==", "nil", "||", "s", ".", "RemoteName", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "s", ".", "RemoteName", "\n", "}" ]

[ "GetRemoteName", "returns", "the", "RemoteName", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "s", "*", "Subscription", ")", "GetIgnored", "(", ")", "bool", "{", "if", "s", "==", "nil", "||", "s", ".", "Ignored", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "s", ".", "Ignored", "\n", "}" ]

[ "GetIgnored", "returns", "the", "Ignored", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "s", "*", "Subscription", ")", "GetSubscribed", "(", ")", "bool", "{", "if", "s", "==", "nil", "||", "s", ".", "Subscribed", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "s", ".", "Subscribed", "\n", "}" ]

[ "GetSubscribed", "returns", "the", "Subscribed", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "s", "*", "Subscription", ")", "GetThreadURL", "(", ")", "string", "{", "if", "s", "==", "nil", "||", "s", ".", "ThreadURL", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "s", ".", "ThreadURL", "\n", "}" ]

[ "GetThreadURL", "returns", "the", "ThreadURL", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "Tag", ")", "GetTag", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "Tag", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "Tag", "\n", "}" ]

[ "GetTag", "returns", "the", "Tag", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "Team", ")", "GetMembersCount", "(", ")", "int", "{", "if", "t", "==", "nil", "||", "t", ".", "MembersCount", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "t", ".", "MembersCount", "\n", "}" ]

[ "GetMembersCount", "returns", "the", "MembersCount", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "Team", ")", "GetReposCount", "(", ")", "int", "{", "if", "t", "==", "nil", "||", "t", ".", "ReposCount", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "t", ".", "ReposCount", "\n", "}" ]

[ "GetReposCount", "returns", "the", "ReposCount", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TeamDiscussion", ")", "GetCommentsCount", "(", ")", "int", "{", "if", "t", "==", "nil", "||", "t", ".", "CommentsCount", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "t", ".", "CommentsCount", "\n", "}" ]

[ "GetCommentsCount", "returns", "the", "CommentsCount", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TeamDiscussion", ")", "GetPinned", "(", ")", "bool", "{", "if", "t", "==", "nil", "||", "t", ".", "Pinned", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "t", ".", "Pinned", "\n", "}" ]

[ "GetPinned", "returns", "the", "Pinned", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TeamDiscussion", ")", "GetTeamURL", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "TeamURL", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "TeamURL", "\n", "}" ]

[ "GetTeamURL", "returns", "the", "TeamURL", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TextMatch", ")", "GetFragment", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "Fragment", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "Fragment", "\n", "}" ]

[ "GetFragment", "returns", "the", "Fragment", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TextMatch", ")", "GetObjectType", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "ObjectType", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "ObjectType", "\n", "}" ]

[ "GetObjectType", "returns", "the", "ObjectType", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TextMatch", ")", "GetObjectURL", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "ObjectURL", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "ObjectURL", "\n", "}" ]

[ "GetObjectURL", "returns", "the", "ObjectURL", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TextMatch", ")", "GetProperty", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "Property", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "Property", "\n", "}" ]

[ "GetProperty", "returns", "the", "Property", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TrafficReferrer", ")", "GetReferrer", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "Referrer", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "Referrer", "\n", "}" ]

[ "GetReferrer", "returns", "the", "Referrer", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "Tree", ")", "GetTruncated", "(", ")", "bool", "{", "if", "t", "==", "nil", "||", "t", ".", "Truncated", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "t", ".", "Truncated", "\n", "}" ]

[ "GetTruncated", "returns", "the", "Truncated", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "t", "*", "TreeEntry", ")", "GetMode", "(", ")", "string", "{", "if", "t", "==", "nil", "||", "t", ".", "Mode", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "t", ".", "Mode", "\n", "}" ]

[ "GetMode", "returns", "the", "Mode", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "User", ")", "GetBio", "(", ")", "string", "{", "if", "u", "==", "nil", "||", "u", ".", "Bio", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "u", ".", "Bio", "\n", "}" ]

[ "GetBio", "returns", "the", "Bio", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "User", ")", "GetHireable", "(", ")", "bool", "{", "if", "u", "==", "nil", "||", "u", ".", "Hireable", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "u", ".", "Hireable", "\n", "}" ]

[ "GetHireable", "returns", "the", "Hireable", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "User", ")", "GetSuspendedAt", "(", ")", "Timestamp", "{", "if", "u", "==", "nil", "||", "u", ".", "SuspendedAt", "==", "nil", "{", "return", "Timestamp", "{", "}", "\n", "}", "\n", "return", "*", "u", ".", "SuspendedAt", "\n", "}" ]

[ "GetSuspendedAt", "returns", "the", "SuspendedAt", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "User", ")", "GetTwoFactorAuthentication", "(", ")", "bool", "{", "if", "u", "==", "nil", "||", "u", ".", "TwoFactorAuthentication", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "u", ".", "TwoFactorAuthentication", "\n", "}" ]

[ "GetTwoFactorAuthentication", "returns", "the", "TwoFactorAuthentication", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "UserContext", ")", "GetOcticon", "(", ")", "string", "{", "if", "u", "==", "nil", "||", "u", ".", "Octicon", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "u", ".", "Octicon", "\n", "}" ]

[ "GetOcticon", "returns", "the", "Octicon", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "UserEmail", ")", "GetPrimary", "(", ")", "bool", "{", "if", "u", "==", "nil", "||", "u", ".", "Primary", "==", "nil", "{", "return", "false", "\n", "}", "\n", "return", "*", "u", ".", "Primary", "\n", "}" ]

[ "GetPrimary", "returns", "the", "Primary", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "UserStats", ")", "GetAdminUsers", "(", ")", "int", "{", "if", "u", "==", "nil", "||", "u", ".", "AdminUsers", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "u", ".", "AdminUsers", "\n", "}" ]

[ "GetAdminUsers", "returns", "the", "AdminUsers", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "UserStats", ")", "GetSuspendedUsers", "(", ")", "int", "{", "if", "u", "==", "nil", "||", "u", ".", "SuspendedUsers", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "u", ".", "SuspendedUsers", "\n", "}" ]

[ "GetSuspendedUsers", "returns", "the", "SuspendedUsers", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "u", "*", "UserStats", ")", "GetTotalUsers", "(", ")", "int", "{", "if", "u", "==", "nil", "||", "u", ".", "TotalUsers", "==", "nil", "{", "return", "0", "\n", "}", "\n", "return", "*", "u", ".", "TotalUsers", "\n", "}" ]

[ "GetTotalUsers", "returns", "the", "TotalUsers", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "w", "*", "WebHookAuthor", ")", "GetUsername", "(", ")", "string", "{", "if", "w", "==", "nil", "||", "w", ".", "Username", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "w", ".", "Username", "\n", "}" ]

[ "GetUsername", "returns", "the", "Username", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "gq", "*", "Schema", ")", "AddImplementation", "(", ")", "error", "{", "// Keep track of all implementations by interface name.", "if", "gq", ".", "implementations", "==", "nil", "{", "gq", ".", "implementations", "=", "map", "[", "string", "]", "[", "]", "*", "Object", "{", "}", "\n", "}", "\n", "for", "_", ",", "ttype", ":=", "range", "gq", ".", "typeMap", "{", "if", "ttype", ",", "ok", ":=", "ttype", ".", "(", "*", "Object", ")", ";", "ok", "{", "for", "_", ",", "iface", ":=", "range", "ttype", ".", "Interfaces", "(", ")", "{", "impls", ",", "ok", ":=", "gq", ".", "implementations", "[", "iface", ".", "Name", "(", ")", "]", "\n", "if", "impls", "==", "nil", "||", "!", "ok", "{", "impls", "=", "[", "]", "*", "Object", "{", "}", "\n", "}", "\n", "impls", "=", "append", "(", "impls", ",", "ttype", ")", "\n", "gq", ".", "implementations", "[", "iface", ".", "Name", "(", ")", "]", "=", "impls", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Enforce correct interface implementations", "for", "_", ",", "ttype", ":=", "range", "gq", ".", "typeMap", "{", "if", "ttype", ",", "ok", ":=", "ttype", ".", "(", "*", "Object", ")", ";", "ok", "{", "for", "_", ",", "iface", ":=", "range", "ttype", ".", "Interfaces", "(", ")", "{", "err", ":=", "assertObjectImplementsInterface", "(", "gq", ",", "ttype", ",", "iface", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Added", "Check", "implementation", "of", "interfaces", "at", "runtime", "..", "Add", "Implementations", "at", "Runtime", ".." ]

[ "func", "(", "gq", "*", "Schema", ")", "AppendType", "(", "objectType", "Type", ")", "error", "{", "if", "objectType", ".", "Error", "(", ")", "!=", "nil", "{", "return", "objectType", ".", "Error", "(", ")", "\n", "}", "\n", "var", "err", "error", "\n", "gq", ".", "typeMap", ",", "err", "=", "typeMapReducer", "(", "gq", ",", "gq", ".", "typeMap", ",", "objectType", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "//Now Add interface implementation..", "return", "gq", ".", "AddImplementation", "(", ")", "\n", "}" ]

[ "Edited", ".", "To", "check", "add", "Types", "at", "RunTime", "..", "Append", "Runtime", "schema", "to", "typeMap" ]

[ "func", "(", "gq", "*", "Schema", ")", "AddExtensions", "(", "e", "...", "Extension", ")", "{", "gq", ".", "extensions", "=", "append", "(", "gq", ".", "extensions", ",", "e", "...", ")", "\n", "}" ]

[ "AddExtensions", "can", "be", "used", "to", "add", "additional", "extensions", "to", "the", "schema" ]

[ "func", "IsInputType", "(", "ttype", "Type", ")", "bool", "{", "switch", "GetNamed", "(", "ttype", ")", ".", "(", "type", ")", "{", "case", "*", "Scalar", ",", "*", "Enum", ",", "*", "InputObject", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsInputType", "determines", "if", "given", "type", "is", "a", "GraphQLInputType" ]

[ "func", "IsOutputType", "(", "ttype", "Type", ")", "bool", "{", "switch", "GetNamed", "(", "ttype", ")", ".", "(", "type", ")", "{", "case", "*", "Scalar", ",", "*", "Object", ",", "*", "Interface", ",", "*", "Union", ",", "*", "Enum", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsOutputType", "determines", "if", "given", "type", "is", "a", "GraphQLOutputType" ]

[ "func", "IsLeafType", "(", "ttype", "Type", ")", "bool", "{", "switch", "GetNamed", "(", "ttype", ")", ".", "(", "type", ")", "{", "case", "*", "Scalar", ",", "*", "Enum", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsLeafType", "determines", "if", "given", "type", "is", "a", "leaf", "value" ]

[ "func", "GetNullable", "(", "ttype", "Type", ")", "Nullable", "{", "if", "ttype", ",", "ok", ":=", "ttype", ".", "(", "*", "NonNull", ")", ";", "ok", "{", "return", "ttype", ".", "OfType", "\n", "}", "\n", "return", "ttype", "\n", "}" ]

[ "GetNullable", "returns", "the", "Nullable", "type", "of", "the", "given", "GraphQL", "type" ]

[ "func", "GetNamed", "(", "ttype", "Type", ")", "Named", "{", "unmodifiedType", ":=", "ttype", "\n", "for", "{", "switch", "typ", ":=", "unmodifiedType", ".", "(", "type", ")", "{", "case", "*", "List", ":", "unmodifiedType", "=", "typ", ".", "OfType", "\n", "case", "*", "NonNull", ":", "unmodifiedType", "=", "typ", ".", "OfType", "\n", "default", ":", "return", "unmodifiedType", "\n", "}", "\n", "}", "\n", "}" ]

[ "GetNamed", "returns", "the", "Named", "type", "of", "the", "given", "GraphQL", "type" ]

[ "func", "NewScalar", "(", "config", "ScalarConfig", ")", "*", "Scalar", "{", "st", ":=", "&", "Scalar", "{", "}", "\n", "err", ":=", "invariant", "(", "config", ".", "Name", "!=", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "st", ".", "err", "=", "err", "\n", "return", "st", "\n", "}", "\n\n", "err", "=", "assertValidName", "(", "config", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "st", ".", "err", "=", "err", "\n", "return", "st", "\n", "}", "\n\n", "st", ".", "PrivateName", "=", "config", ".", "Name", "\n", "st", ".", "PrivateDescription", "=", "config", ".", "Description", "\n\n", "err", "=", "invariantf", "(", "config", ".", "Serialize", "!=", "nil", ",", "`%v must provide \"serialize\" function. If this custom Scalar is `", "+", "`also used as an input type, ensure \"parseValue\" and \"parseLiteral\" `", "+", "`functions are also provided.`", ",", "st", ",", ")", "\n", "if", "err", "!=", "nil", "{", "st", ".", "err", "=", "err", "\n", "return", "st", "\n", "}", "\n", "if", "config", ".", "ParseValue", "!=", "nil", "||", "config", ".", "ParseLiteral", "!=", "nil", "{", "err", "=", "invariantf", "(", "config", ".", "ParseValue", "!=", "nil", "&&", "config", ".", "ParseLiteral", "!=", "nil", ",", "`%v must provide both \"parseValue\" and \"parseLiteral\" functions.`", ",", "st", ",", ")", "\n", "if", "err", "!=", "nil", "{", "st", ".", "err", "=", "err", "\n", "return", "st", "\n", "}", "\n", "}", "\n\n", "st", ".", "scalarConfig", "=", "config", "\n", "return", "st", "\n", "}" ]

[ "NewScalar", "creates", "a", "new", "GraphQLScalar" ]

[ "func", "(", "p", "*", "ResponsePath", ")", "WithKey", "(", "key", "interface", "{", "}", ")", "*", "ResponsePath", "{", "return", "&", "ResponsePath", "{", "Prev", ":", "p", ",", "Key", ":", "key", ",", "}", "\n", "}" ]

[ "WithKey", "returns", "a", "new", "responsePath", "containing", "the", "new", "key", "." ]

[ "func", "(", "p", "*", "ResponsePath", ")", "AsArray", "(", ")", "[", "]", "interface", "{", "}", "{", "if", "p", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "append", "(", "p", ".", "Prev", ".", "AsArray", "(", ")", ",", "p", ".", "Key", ")", "\n", "}" ]

[ "AsArray", "returns", "an", "array", "of", "path", "keys", "." ]

[ "func", "getOperationRootType", "(", "schema", "Schema", ",", "operation", "ast", ".", "Definition", ")", "(", "*", "Object", ",", "error", ")", "{", "if", "operation", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "switch", "operation", ".", "GetOperation", "(", ")", "{", "case", "ast", ".", "OperationTypeQuery", ":", "return", "schema", ".", "QueryType", "(", ")", ",", "nil", "\n", "case", "ast", ".", "OperationTypeMutation", ":", "mutationType", ":=", "schema", ".", "MutationType", "(", ")", "\n", "if", "mutationType", "==", "nil", "||", "mutationType", ".", "PrivateName", "==", "\"", "\"", "{", "return", "nil", ",", "gqlerrors", ".", "NewError", "(", "\"", "\"", ",", "[", "]", "ast", ".", "Node", "{", "operation", "}", ",", "\"", "\"", ",", "nil", ",", "[", "]", "int", "{", "}", ",", "nil", ",", ")", "\n", "}", "\n", "return", "mutationType", ",", "nil", "\n", "case", "ast", ".", "OperationTypeSubscription", ":", "subscriptionType", ":=", "schema", ".", "SubscriptionType", "(", ")", "\n", "if", "subscriptionType", "==", "nil", "||", "subscriptionType", ".", "PrivateName", "==", "\"", "\"", "{", "return", "nil", ",", "gqlerrors", ".", "NewError", "(", "\"", "\"", ",", "[", "]", "ast", ".", "Node", "{", "operation", "}", ",", "\"", "\"", ",", "nil", ",", "[", "]", "int", "{", "}", ",", "nil", ",", ")", "\n", "}", "\n", "return", "subscriptionType", ",", "nil", "\n", "default", ":", "return", "nil", ",", "gqlerrors", ".", "NewError", "(", "\"", "\"", ",", "[", "]", "ast", ".", "Node", "{", "operation", "}", ",", "\"", "\"", ",", "nil", ",", "[", "]", "int", "{", "}", ",", "nil", ",", ")", "\n", "}", "\n", "}" ]

[ "Extracts", "the", "root", "type", "of", "the", "operation", "from", "the", "schema", "." ]

[ "func", "executeFieldsSerially", "(", "p", "executeFieldsParams", ")", "*", "Result", "{", "if", "p", ".", "Source", "==", "nil", "{", "p", ".", "Source", "=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "}", "\n", "if", "p", ".", "Fields", "==", "nil", "{", "p", ".", "Fields", "=", "map", "[", "string", "]", "[", "]", "*", "ast", ".", "Field", "{", "}", "\n", "}", "\n\n", "finalResults", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "p", ".", "Fields", ")", ")", "\n", "for", "responseName", ",", "fieldASTs", ":=", "range", "p", ".", "Fields", "{", "fieldPath", ":=", "p", ".", "Path", ".", "WithKey", "(", "responseName", ")", "\n", "resolved", ",", "state", ":=", "resolveField", "(", "p", ".", "ExecutionContext", ",", "p", ".", "ParentType", ",", "p", ".", "Source", ",", "fieldASTs", ",", "fieldPath", ")", "\n", "if", "state", ".", "hasNoFieldDefs", "{", "continue", "\n", "}", "\n", "finalResults", "[", "responseName", "]", "=", "resolved", "\n", "}", "\n", "dethunkMapDepthFirst", "(", "finalResults", ")", "\n\n", "return", "&", "Result", "{", "Data", ":", "finalResults", ",", "Errors", ":", "p", ".", "ExecutionContext", ".", "Errors", ",", "}", "\n", "}" ]

[ "Implements", "the", "Evaluating", "selection", "sets", "section", "of", "the", "spec", "for", "write", "mode", "." ]

[ "func", "executeFields", "(", "p", "executeFieldsParams", ")", "*", "Result", "{", "finalResults", ":=", "executeSubFields", "(", "p", ")", "\n\n", "dethunkMapWithBreadthFirstTraversal", "(", "finalResults", ")", "\n\n", "return", "&", "Result", "{", "Data", ":", "finalResults", ",", "Errors", ":", "p", ".", "ExecutionContext", ".", "Errors", ",", "}", "\n", "}" ]

[ "Implements", "the", "Evaluating", "selection", "sets", "section", "of", "the", "spec", "for", "read", "mode", "." ]

[ "func", "collectFields", "(", "p", "collectFieldsParams", ")", "(", "fields", "map", "[", "string", "]", "[", "]", "*", "ast", ".", "Field", ")", "{", "// overlying SelectionSet & Fields to fields", "if", "p", ".", "SelectionSet", "==", "nil", "{", "return", "p", ".", "Fields", "\n", "}", "\n", "fields", "=", "p", ".", "Fields", "\n", "if", "fields", "==", "nil", "{", "fields", "=", "map", "[", "string", "]", "[", "]", "*", "ast", ".", "Field", "{", "}", "\n", "}", "\n", "if", "p", ".", "VisitedFragmentNames", "==", "nil", "{", "p", ".", "VisitedFragmentNames", "=", "map", "[", "string", "]", "bool", "{", "}", "\n", "}", "\n", "for", "_", ",", "iSelection", ":=", "range", "p", ".", "SelectionSet", ".", "Selections", "{", "switch", "selection", ":=", "iSelection", ".", "(", "type", ")", "{", "case", "*", "ast", ".", "Field", ":", "if", "!", "shouldIncludeNode", "(", "p", ".", "ExeContext", ",", "selection", ".", "Directives", ")", "{", "continue", "\n", "}", "\n", "name", ":=", "getFieldEntryKey", "(", "selection", ")", "\n", "if", "_", ",", "ok", ":=", "fields", "[", "name", "]", ";", "!", "ok", "{", "fields", "[", "name", "]", "=", "[", "]", "*", "ast", ".", "Field", "{", "}", "\n", "}", "\n", "fields", "[", "name", "]", "=", "append", "(", "fields", "[", "name", "]", ",", "selection", ")", "\n", "case", "*", "ast", ".", "InlineFragment", ":", "if", "!", "shouldIncludeNode", "(", "p", ".", "ExeContext", ",", "selection", ".", "Directives", ")", "||", "!", "doesFragmentConditionMatch", "(", "p", ".", "ExeContext", ",", "selection", ",", "p", ".", "RuntimeType", ")", "{", "continue", "\n", "}", "\n", "innerParams", ":=", "collectFieldsParams", "{", "ExeContext", ":", "p", ".", "ExeContext", ",", "RuntimeType", ":", "p", ".", "RuntimeType", ",", "SelectionSet", ":", "selection", ".", "SelectionSet", ",", "Fields", ":", "fields", ",", "VisitedFragmentNames", ":", "p", ".", "VisitedFragmentNames", ",", "}", "\n", "collectFields", "(", "innerParams", ")", "\n", "case", "*", "ast", ".", "FragmentSpread", ":", "fragName", ":=", "\"", "\"", "\n", "if", "selection", ".", "Name", "!=", "nil", "{", "fragName", "=", "selection", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "visited", ",", "ok", ":=", "p", ".", "VisitedFragmentNames", "[", "fragName", "]", ";", "(", "ok", "&&", "visited", ")", "||", "!", "shouldIncludeNode", "(", "p", ".", "ExeContext", ",", "selection", ".", "Directives", ")", "{", "continue", "\n", "}", "\n", "p", ".", "VisitedFragmentNames", "[", "fragName", "]", "=", "true", "\n", "fragment", ",", "hasFragment", ":=", "p", ".", "ExeContext", ".", "Fragments", "[", "fragName", "]", "\n", "if", "!", "hasFragment", "{", "continue", "\n", "}", "\n\n", "if", "fragment", ",", "ok", ":=", "fragment", ".", "(", "*", "ast", ".", "FragmentDefinition", ")", ";", "ok", "{", "if", "!", "doesFragmentConditionMatch", "(", "p", ".", "ExeContext", ",", "fragment", ",", "p", ".", "RuntimeType", ")", "{", "continue", "\n", "}", "\n", "innerParams", ":=", "collectFieldsParams", "{", "ExeContext", ":", "p", ".", "ExeContext", ",", "RuntimeType", ":", "p", ".", "RuntimeType", ",", "SelectionSet", ":", "fragment", ".", "GetSelectionSet", "(", ")", ",", "Fields", ":", "fields", ",", "VisitedFragmentNames", ":", "p", ".", "VisitedFragmentNames", ",", "}", "\n", "collectFields", "(", "innerParams", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "fields", "\n", "}" ]

[ "Given", "a", "selectionSet", "adds", "all", "of", "the", "fields", "in", "that", "selection", "to", "the", "passed", "in", "map", "of", "fields", "and", "returns", "it", "at", "the", "end", ".", "CollectFields", "requires", "the", "runtime", "type", "of", "an", "object", ".", "For", "a", "field", "which", "returns", "and", "Interface", "or", "Union", "type", "the", "runtime", "type", "will", "be", "the", "actual", "Object", "type", "returned", "by", "that", "field", "." ]

[ "func", "shouldIncludeNode", "(", "eCtx", "*", "executionContext", ",", "directives", "[", "]", "*", "ast", ".", "Directive", ")", "bool", "{", "var", "(", "skipAST", ",", "includeAST", "*", "ast", ".", "Directive", "\n", "argValues", "map", "[", "string", "]", "interface", "{", "}", "\n", ")", "\n", "for", "_", ",", "directive", ":=", "range", "directives", "{", "if", "directive", "==", "nil", "||", "directive", ".", "Name", "==", "nil", "{", "continue", "\n", "}", "\n", "switch", "directive", ".", "Name", ".", "Value", "{", "case", "SkipDirective", ".", "Name", ":", "skipAST", "=", "directive", "\n", "case", "IncludeDirective", ".", "Name", ":", "includeAST", "=", "directive", "\n", "}", "\n", "}", "\n", "// precedence: skipAST > includeAST", "if", "skipAST", "!=", "nil", "{", "argValues", "=", "getArgumentValues", "(", "SkipDirective", ".", "Args", ",", "skipAST", ".", "Arguments", ",", "eCtx", ".", "VariableValues", ")", "\n", "if", "skipIf", ",", "ok", ":=", "argValues", "[", "\"", "\"", "]", ".", "(", "bool", ")", ";", "ok", "&&", "skipIf", "{", "return", "false", "// excluded selectionSet's fields", "\n", "}", "\n", "}", "\n", "if", "includeAST", "!=", "nil", "{", "argValues", "=", "getArgumentValues", "(", "IncludeDirective", ".", "Args", ",", "includeAST", ".", "Arguments", ",", "eCtx", ".", "VariableValues", ")", "\n", "if", "includeIf", ",", "ok", ":=", "argValues", "[", "\"", "\"", "]", ".", "(", "bool", ")", ";", "ok", "&&", "!", "includeIf", "{", "return", "false", "// excluded selectionSet's fields", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Determines", "if", "a", "field", "should", "be", "included", "based", "on", "the" ]

[ "func", "doesFragmentConditionMatch", "(", "eCtx", "*", "executionContext", ",", "fragment", "ast", ".", "Node", ",", "ttype", "*", "Object", ")", "bool", "{", "switch", "fragment", ":=", "fragment", ".", "(", "type", ")", "{", "case", "*", "ast", ".", "FragmentDefinition", ":", "typeConditionAST", ":=", "fragment", ".", "TypeCondition", "\n", "if", "typeConditionAST", "==", "nil", "{", "return", "true", "\n", "}", "\n", "conditionalType", ",", "err", ":=", "typeFromAST", "(", "eCtx", ".", "Schema", ",", "typeConditionAST", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "if", "conditionalType", "==", "ttype", "{", "return", "true", "\n", "}", "\n", "if", "conditionalType", ".", "Name", "(", ")", "==", "ttype", ".", "Name", "(", ")", "{", "return", "true", "\n", "}", "\n", "if", "conditionalType", ",", "ok", ":=", "conditionalType", ".", "(", "*", "Interface", ")", ";", "ok", "{", "return", "eCtx", ".", "Schema", ".", "IsPossibleType", "(", "conditionalType", ",", "ttype", ")", "\n", "}", "\n", "if", "conditionalType", ",", "ok", ":=", "conditionalType", ".", "(", "*", "Union", ")", ";", "ok", "{", "return", "eCtx", ".", "Schema", ".", "IsPossibleType", "(", "conditionalType", ",", "ttype", ")", "\n", "}", "\n", "case", "*", "ast", ".", "InlineFragment", ":", "typeConditionAST", ":=", "fragment", ".", "TypeCondition", "\n", "if", "typeConditionAST", "==", "nil", "{", "return", "true", "\n", "}", "\n", "conditionalType", ",", "err", ":=", "typeFromAST", "(", "eCtx", ".", "Schema", ",", "typeConditionAST", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "if", "conditionalType", "==", "ttype", "{", "return", "true", "\n", "}", "\n", "if", "conditionalType", ".", "Name", "(", ")", "==", "ttype", ".", "Name", "(", ")", "{", "return", "true", "\n", "}", "\n", "if", "conditionalType", ",", "ok", ":=", "conditionalType", ".", "(", "*", "Interface", ")", ";", "ok", "{", "return", "eCtx", ".", "Schema", ".", "IsPossibleType", "(", "conditionalType", ",", "ttype", ")", "\n", "}", "\n", "if", "conditionalType", ",", "ok", ":=", "conditionalType", ".", "(", "*", "Union", ")", ";", "ok", "{", "return", "eCtx", ".", "Schema", ".", "IsPossibleType", "(", "conditionalType", ",", "ttype", ")", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "Determines", "if", "a", "fragment", "is", "applicable", "to", "the", "given", "type", "." ]

[ "func", "resolveField", "(", "eCtx", "*", "executionContext", ",", "parentType", "*", "Object", ",", "source", "interface", "{", "}", ",", "fieldASTs", "[", "]", "*", "ast", ".", "Field", ",", "path", "*", "ResponsePath", ")", "(", "result", "interface", "{", "}", ",", "resultState", "resolveFieldResultState", ")", "{", "// catch panic from resolveFn", "var", "returnType", "Output", "\n", "defer", "func", "(", ")", "(", "interface", "{", "}", ",", "resolveFieldResultState", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "handleFieldError", "(", "r", ",", "FieldASTsToNodeASTs", "(", "fieldASTs", ")", ",", "path", ",", "returnType", ",", "eCtx", ")", "\n", "return", "result", ",", "resultState", "\n", "}", "\n", "return", "result", ",", "resultState", "\n", "}", "(", ")", "\n\n", "fieldAST", ":=", "fieldASTs", "[", "0", "]", "\n", "fieldName", ":=", "\"", "\"", "\n", "if", "fieldAST", ".", "Name", "!=", "nil", "{", "fieldName", "=", "fieldAST", ".", "Name", ".", "Value", "\n", "}", "\n\n", "fieldDef", ":=", "getFieldDef", "(", "eCtx", ".", "Schema", ",", "parentType", ",", "fieldName", ")", "\n", "if", "fieldDef", "==", "nil", "{", "resultState", ".", "hasNoFieldDefs", "=", "true", "\n", "return", "nil", ",", "resultState", "\n", "}", "\n", "returnType", "=", "fieldDef", ".", "Type", "\n", "resolveFn", ":=", "fieldDef", ".", "Resolve", "\n", "if", "resolveFn", "==", "nil", "{", "resolveFn", "=", "DefaultResolveFn", "\n", "}", "\n\n", "// Build a map of arguments from the field.arguments AST, using the", "// variables scope to fulfill any variable references.", "// TODO: find a way to memoize, in case this field is within a List type.", "args", ":=", "getArgumentValues", "(", "fieldDef", ".", "Args", ",", "fieldAST", ".", "Arguments", ",", "eCtx", ".", "VariableValues", ")", "\n\n", "info", ":=", "ResolveInfo", "{", "FieldName", ":", "fieldName", ",", "FieldASTs", ":", "fieldASTs", ",", "Path", ":", "path", ",", "ReturnType", ":", "returnType", ",", "ParentType", ":", "parentType", ",", "Schema", ":", "eCtx", ".", "Schema", ",", "Fragments", ":", "eCtx", ".", "Fragments", ",", "RootValue", ":", "eCtx", ".", "Root", ",", "Operation", ":", "eCtx", ".", "Operation", ",", "VariableValues", ":", "eCtx", ".", "VariableValues", ",", "}", "\n\n", "var", "resolveFnError", "error", "\n\n", "extErrs", ",", "resolveFieldFinishFn", ":=", "handleExtensionsResolveFieldDidStart", "(", "eCtx", ".", "Schema", ".", "extensions", ",", "eCtx", ",", "&", "info", ")", "\n", "if", "len", "(", "extErrs", ")", "!=", "0", "{", "eCtx", ".", "Errors", "=", "append", "(", "eCtx", ".", "Errors", ",", "extErrs", "...", ")", "\n", "}", "\n\n", "result", ",", "resolveFnError", "=", "resolveFn", "(", "ResolveParams", "{", "Source", ":", "source", ",", "Args", ":", "args", ",", "Info", ":", "info", ",", "Context", ":", "eCtx", ".", "Context", ",", "}", ")", "\n\n", "if", "resolveFnError", "!=", "nil", "{", "panic", "(", "resolveFnError", ")", "\n", "}", "\n\n", "extErrs", "=", "resolveFieldFinishFn", "(", "result", ",", "resolveFnError", ")", "\n", "if", "len", "(", "extErrs", ")", "!=", "0", "{", "eCtx", ".", "Errors", "=", "append", "(", "eCtx", ".", "Errors", ",", "extErrs", "...", ")", "\n", "}", "\n\n", "completed", ":=", "completeValueCatchingError", "(", "eCtx", ",", "returnType", ",", "fieldASTs", ",", "info", ",", "path", ",", "result", ")", "\n", "return", "completed", ",", "resultState", "\n", "}" ]

[ "Resolves", "the", "field", "on", "the", "given", "source", "object", ".", "In", "particular", "this", "figures", "out", "the", "value", "that", "the", "field", "returns", "by", "calling", "its", "resolve", "function", "then", "calls", "completeValue", "to", "complete", "promises", "serialize", "scalars", "or", "execute", "the", "sub", "-", "selection", "-", "set", "for", "objects", "." ]

[ "func", "completeObjectValue", "(", "eCtx", "*", "executionContext", ",", "returnType", "*", "Object", ",", "fieldASTs", "[", "]", "*", "ast", ".", "Field", ",", "info", "ResolveInfo", ",", "path", "*", "ResponsePath", ",", "result", "interface", "{", "}", ")", "interface", "{", "}", "{", "// If there is an isTypeOf predicate function, call it with the", "// current result. If isTypeOf returns false, then raise an error rather", "// than continuing execution.", "if", "returnType", ".", "IsTypeOf", "!=", "nil", "{", "p", ":=", "IsTypeOfParams", "{", "Value", ":", "result", ",", "Info", ":", "info", ",", "Context", ":", "eCtx", ".", "Context", ",", "}", "\n", "if", "!", "returnType", ".", "IsTypeOf", "(", "p", ")", "{", "panic", "(", "gqlerrors", ".", "NewFormattedError", "(", "fmt", ".", "Sprintf", "(", "`Expected value of type \"%v\" but got: %T.`", ",", "returnType", ",", "result", ")", ",", ")", ")", "\n", "}", "\n", "}", "\n\n", "// Collect sub-fields to execute to complete this value.", "subFieldASTs", ":=", "map", "[", "string", "]", "[", "]", "*", "ast", ".", "Field", "{", "}", "\n", "visitedFragmentNames", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "for", "_", ",", "fieldAST", ":=", "range", "fieldASTs", "{", "if", "fieldAST", "==", "nil", "{", "continue", "\n", "}", "\n", "selectionSet", ":=", "fieldAST", ".", "SelectionSet", "\n", "if", "selectionSet", "!=", "nil", "{", "innerParams", ":=", "collectFieldsParams", "{", "ExeContext", ":", "eCtx", ",", "RuntimeType", ":", "returnType", ",", "SelectionSet", ":", "selectionSet", ",", "Fields", ":", "subFieldASTs", ",", "VisitedFragmentNames", ":", "visitedFragmentNames", ",", "}", "\n", "subFieldASTs", "=", "collectFields", "(", "innerParams", ")", "\n", "}", "\n", "}", "\n", "executeFieldsParams", ":=", "executeFieldsParams", "{", "ExecutionContext", ":", "eCtx", ",", "ParentType", ":", "returnType", ",", "Source", ":", "result", ",", "Fields", ":", "subFieldASTs", ",", "Path", ":", "path", ",", "}", "\n", "return", "executeSubFields", "(", "executeFieldsParams", ")", "\n", "}" ]

[ "completeObjectValue", "complete", "an", "Object", "value", "by", "executing", "all", "sub", "-", "selections", "." ]

[ "func", "completeListValue", "(", "eCtx", "*", "executionContext", ",", "returnType", "*", "List", ",", "fieldASTs", "[", "]", "*", "ast", ".", "Field", ",", "info", "ResolveInfo", ",", "path", "*", "ResponsePath", ",", "result", "interface", "{", "}", ")", "interface", "{", "}", "{", "resultVal", ":=", "reflect", ".", "ValueOf", "(", "result", ")", "\n", "if", "resultVal", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "resultVal", "=", "resultVal", ".", "Elem", "(", ")", "\n", "}", "\n", "parentTypeName", ":=", "\"", "\"", "\n", "if", "info", ".", "ParentType", "!=", "nil", "{", "parentTypeName", "=", "info", ".", "ParentType", ".", "Name", "(", ")", "\n", "}", "\n", "err", ":=", "invariantf", "(", "resultVal", ".", "IsValid", "(", ")", "&&", "isIterable", "(", "result", ")", ",", "\"", "\"", "+", "\"", "\"", ",", "parentTypeName", ",", "info", ".", "FieldName", ")", "\n\n", "if", "err", "!=", "nil", "{", "panic", "(", "gqlerrors", ".", "FormatError", "(", "err", ")", ")", "\n", "}", "\n\n", "itemType", ":=", "returnType", ".", "OfType", "\n", "completedResults", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "resultVal", ".", "Len", "(", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "resultVal", ".", "Len", "(", ")", ";", "i", "++", "{", "val", ":=", "resultVal", ".", "Index", "(", "i", ")", ".", "Interface", "(", ")", "\n", "fieldPath", ":=", "path", ".", "WithKey", "(", "i", ")", "\n", "completedItem", ":=", "completeValueCatchingError", "(", "eCtx", ",", "itemType", ",", "fieldASTs", ",", "info", ",", "fieldPath", ",", "val", ")", "\n", "completedResults", "=", "append", "(", "completedResults", ",", "completedItem", ")", "\n", "}", "\n", "return", "completedResults", "\n", "}" ]

[ "completeListValue", "complete", "a", "list", "value", "by", "completing", "each", "item", "in", "the", "list", "with", "the", "inner", "type" ]

[ "func", "defaultResolveTypeFn", "(", "p", "ResolveTypeParams", ",", "abstractType", "Abstract", ")", "*", "Object", "{", "possibleTypes", ":=", "p", ".", "Info", ".", "Schema", ".", "PossibleTypes", "(", "abstractType", ")", "\n", "for", "_", ",", "possibleType", ":=", "range", "possibleTypes", "{", "if", "possibleType", ".", "IsTypeOf", "==", "nil", "{", "continue", "\n", "}", "\n", "isTypeOfParams", ":=", "IsTypeOfParams", "{", "Value", ":", "p", ".", "Value", ",", "Info", ":", "p", ".", "Info", ",", "Context", ":", "p", ".", "Context", ",", "}", "\n", "if", "res", ":=", "possibleType", ".", "IsTypeOf", "(", "isTypeOfParams", ")", ";", "res", "{", "return", "possibleType", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "defaultResolveTypeFn", "If", "a", "resolveType", "function", "is", "not", "given", "then", "a", "default", "resolve", "behavior", "is", "used", "which", "tests", "each", "possible", "type", "for", "the", "abstract", "type", "by", "calling", "isTypeOf", "for", "the", "object", "being", "coerced", "returning", "the", "first", "type", "that", "matches", "." ]

[ "func", "handleExtensionsInits", "(", "p", "*", "Params", ")", "gqlerrors", ".", "FormattedErrors", "{", "errs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "_", ",", "ext", ":=", "range", "p", ".", "Schema", ".", "extensions", "{", "func", "(", ")", "{", "// catch panic from an extension init fn", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ext", ".", "Name", "(", ")", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "// update context", "p", ".", "Context", "=", "ext", ".", "Init", "(", "p", ".", "Context", ",", "p", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "errs", "\n", "}" ]

[ "handleExtensionsInits", "handles", "all", "the", "init", "functions", "for", "all", "the", "extensions", "in", "the", "schema" ]

[ "func", "handleExtensionsParseDidStart", "(", "p", "*", "Params", ")", "(", "[", "]", "gqlerrors", ".", "FormattedError", ",", "parseFinishFuncHandler", ")", "{", "fs", ":=", "map", "[", "string", "]", "ParseFinishFunc", "{", "}", "\n", "errs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "_", ",", "ext", ":=", "range", "p", ".", "Schema", ".", "extensions", "{", "var", "(", "ctx", "context", ".", "Context", "\n", "finishFn", "ParseFinishFunc", "\n", ")", "\n", "// catch panic from an extension's parseDidStart functions", "func", "(", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ext", ".", "Name", "(", ")", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "ctx", ",", "finishFn", "=", "ext", ".", "ParseDidStart", "(", "p", ".", "Context", ")", "\n", "// update context", "p", ".", "Context", "=", "ctx", "\n", "fs", "[", "ext", ".", "Name", "(", ")", "]", "=", "finishFn", "\n", "}", "(", ")", "\n", "}", "\n", "return", "errs", ",", "func", "(", "err", "error", ")", "[", "]", "gqlerrors", ".", "FormattedError", "{", "errs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "name", ",", "fn", ":=", "range", "fs", "{", "func", "(", ")", "{", "// catch panic from a finishFn", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "fn", "(", "err", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "errs", "\n", "}", "\n", "}" ]

[ "handleExtensionsParseDidStart", "runs", "the", "ParseDidStart", "functions", "for", "each", "extension" ]

[ "func", "handleExtensionsValidationDidStart", "(", "p", "*", "Params", ")", "(", "[", "]", "gqlerrors", ".", "FormattedError", ",", "validationFinishFuncHandler", ")", "{", "fs", ":=", "map", "[", "string", "]", "ValidationFinishFunc", "{", "}", "\n", "errs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "_", ",", "ext", ":=", "range", "p", ".", "Schema", ".", "extensions", "{", "var", "(", "ctx", "context", ".", "Context", "\n", "finishFn", "ValidationFinishFunc", "\n", ")", "\n", "// catch panic from an extension's validationDidStart function", "func", "(", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ext", ".", "Name", "(", ")", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "ctx", ",", "finishFn", "=", "ext", ".", "ValidationDidStart", "(", "p", ".", "Context", ")", "\n", "// update context", "p", ".", "Context", "=", "ctx", "\n", "fs", "[", "ext", ".", "Name", "(", ")", "]", "=", "finishFn", "\n", "}", "(", ")", "\n", "}", "\n", "return", "errs", ",", "func", "(", "errs", "[", "]", "gqlerrors", ".", "FormattedError", ")", "[", "]", "gqlerrors", ".", "FormattedError", "{", "extErrs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "name", ",", "finishFn", ":=", "range", "fs", "{", "func", "(", ")", "{", "// catch panic from a finishFn", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "extErrs", "=", "append", "(", "extErrs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "finishFn", "(", "errs", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "extErrs", "\n", "}", "\n", "}" ]

[ "handleExtensionsValidationDidStart", "notifies", "the", "extensions", "about", "the", "start", "of", "the", "validation", "process" ]

[ "func", "handleExtensionsExecutionDidStart", "(", "p", "*", "ExecuteParams", ")", "(", "[", "]", "gqlerrors", ".", "FormattedError", ",", "executionFinishFuncHandler", ")", "{", "fs", ":=", "map", "[", "string", "]", "ExecutionFinishFunc", "{", "}", "\n", "errs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "_", ",", "ext", ":=", "range", "p", ".", "Schema", ".", "extensions", "{", "var", "(", "ctx", "context", ".", "Context", "\n", "finishFn", "ExecutionFinishFunc", "\n", ")", "\n", "// catch panic from an extension's executionDidStart function", "func", "(", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ext", ".", "Name", "(", ")", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "ctx", ",", "finishFn", "=", "ext", ".", "ExecutionDidStart", "(", "p", ".", "Context", ")", "\n", "// update context", "p", ".", "Context", "=", "ctx", "\n", "fs", "[", "ext", ".", "Name", "(", ")", "]", "=", "finishFn", "\n", "}", "(", ")", "\n", "}", "\n", "return", "errs", ",", "func", "(", "result", "*", "Result", ")", "[", "]", "gqlerrors", ".", "FormattedError", "{", "extErrs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "name", ",", "finishFn", ":=", "range", "fs", "{", "func", "(", ")", "{", "// catch panic from a finishFn", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "extErrs", "=", "append", "(", "extErrs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "finishFn", "(", "result", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "extErrs", "\n", "}", "\n", "}" ]

[ "handleExecutionDidStart", "handles", "the", "ExecutionDidStart", "functions" ]

[ "func", "handleExtensionsResolveFieldDidStart", "(", "exts", "[", "]", "Extension", ",", "p", "*", "executionContext", ",", "i", "*", "ResolveInfo", ")", "(", "[", "]", "gqlerrors", ".", "FormattedError", ",", "resolveFieldFinishFuncHandler", ")", "{", "fs", ":=", "map", "[", "string", "]", "ResolveFieldFinishFunc", "{", "}", "\n", "errs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "_", ",", "ext", ":=", "range", "p", ".", "Schema", ".", "extensions", "{", "var", "(", "ctx", "context", ".", "Context", "\n", "finishFn", "ResolveFieldFinishFunc", "\n", ")", "\n", "// catch panic from an extension's resolveFieldDidStart function", "func", "(", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ext", ".", "Name", "(", ")", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "ctx", ",", "finishFn", "=", "ext", ".", "ResolveFieldDidStart", "(", "p", ".", "Context", ",", "i", ")", "\n", "// update context", "p", ".", "Context", "=", "ctx", "\n", "fs", "[", "ext", ".", "Name", "(", ")", "]", "=", "finishFn", "\n", "}", "(", ")", "\n", "}", "\n", "return", "errs", ",", "func", "(", "val", "interface", "{", "}", ",", "err", "error", ")", "[", "]", "gqlerrors", ".", "FormattedError", "{", "extErrs", ":=", "gqlerrors", ".", "FormattedErrors", "{", "}", "\n", "for", "name", ",", "finishFn", ":=", "range", "fs", "{", "func", "(", ")", "{", "// catch panic from a finishFn", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "extErrs", "=", "append", "(", "extErrs", ",", "gqlerrors", ".", "FormatError", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "r", ".", "(", "error", ")", ")", ")", ")", "\n", "}", "\n", "}", "(", ")", "\n", "finishFn", "(", "val", ",", "err", ")", "\n", "}", "(", ")", "\n", "}", "\n", "return", "extErrs", "\n", "}", "\n", "}" ]

[ "handleResolveFieldDidStart", "handles", "the", "notification", "of", "the", "extensions", "about", "the", "start", "of", "a", "resolve", "function" ]

[ "func", "VisitUsingRules", "(", "schema", "*", "Schema", ",", "typeInfo", "*", "TypeInfo", ",", "astDoc", "*", "ast", ".", "Document", ",", "rules", "[", "]", "ValidationRuleFn", ")", "[", "]", "gqlerrors", ".", "FormattedError", "{", "context", ":=", "NewValidationContext", "(", "schema", ",", "astDoc", ",", "typeInfo", ")", "\n", "visitors", ":=", "[", "]", "*", "visitor", ".", "VisitorOptions", "{", "}", "\n\n", "for", "_", ",", "rule", ":=", "range", "rules", "{", "instance", ":=", "rule", "(", "context", ")", "\n", "visitors", "=", "append", "(", "visitors", ",", "instance", ".", "VisitorOpts", ")", "\n", "}", "\n\n", "// Visit the whole document with each instance of all provided rules.", "visitor", ".", "Visit", "(", "astDoc", ",", "visitor", ".", "VisitWithTypeInfo", "(", "typeInfo", ",", "visitor", ".", "VisitInParallel", "(", "visitors", "...", ")", ")", ",", "nil", ")", "\n", "return", "context", ".", "Errors", "(", ")", "\n", "}" ]

[ "VisitUsingRules", "This", "uses", "a", "specialized", "visitor", "which", "runs", "multiple", "visitors", "in", "parallel", "while", "maintaining", "the", "visitor", "skip", "and", "break", "API", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "findConflictsWithinSelectionSet", "(", "parentType", "Named", ",", "selectionSet", "*", "ast", ".", "SelectionSet", ")", "[", "]", "conflict", "{", "conflicts", ":=", "[", "]", "conflict", "{", "}", "\n\n", "fieldsInfo", ":=", "rule", ".", "getFieldsAndFragmentNames", "(", "parentType", ",", "selectionSet", ")", "\n\n", "// (A) Find find all conflicts \"within\" the fields of this selection set.", "// Note: this is the *only place* `collectConflictsWithin` is called.", "conflicts", "=", "rule", ".", "collectConflictsWithin", "(", "conflicts", ",", "fieldsInfo", ")", "\n\n", "// (B) Then collect conflicts between these fields and those represented by", "// each spread fragment name found.", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "fieldsInfo", ".", "fragmentNames", ")", ";", "i", "++", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFieldsAndFragment", "(", "conflicts", ",", "false", ",", "fieldsInfo", ",", "fieldsInfo", ".", "fragmentNames", "[", "i", "]", ")", "\n\n", "// (C) Then compare this fragment with all other fragments found in this", "// selection set to collect conflicts between fragments spread together.", "// This compares each item in the list of fragment names to every other item", "// in that same list (except for itself).", "for", "k", ":=", "i", "+", "1", ";", "k", "<", "len", "(", "fieldsInfo", ".", "fragmentNames", ")", ";", "k", "++", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFragments", "(", "conflicts", ",", "false", ",", "fieldsInfo", ".", "fragmentNames", "[", "i", "]", ",", "fieldsInfo", ".", "fragmentNames", "[", "k", "]", ")", "\n", "}", "\n", "}", "\n", "return", "conflicts", "\n", "}" ]

[ "Find", "all", "conflicts", "found", "within", "a", "selection", "set", "including", "those", "found", "via", "spreading", "in", "fragments", ".", "Called", "when", "visiting", "each", "SelectionSet", "in", "the", "GraphQL", "Document", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "collectConflictsBetweenFieldsAndFragment", "(", "conflicts", "[", "]", "conflict", ",", "areMutuallyExclusive", "bool", ",", "fieldsInfo", "*", "fieldsAndFragmentNames", ",", "fragmentName", "string", ")", "[", "]", "conflict", "{", "fragment", ":=", "rule", ".", "context", ".", "Fragment", "(", "fragmentName", ")", "\n", "if", "fragment", "==", "nil", "{", "return", "conflicts", "\n", "}", "\n\n", "fieldsInfo2", ":=", "rule", ".", "getReferencedFieldsAndFragmentNames", "(", "fragment", ")", "\n\n", "// (D) First collect any conflicts between the provided collection of fields", "// and the collection of fields represented by the given fragment.", "conflicts", "=", "rule", ".", "collectConflictsBetween", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fieldsInfo", ",", "fieldsInfo2", ")", "\n\n", "// (E) Then collect any conflicts between the provided collection of fields", "// and any fragment names found in the given fragment.", "for", "_", ",", "fragmentName2", ":=", "range", "fieldsInfo2", ".", "fragmentNames", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFieldsAndFragment", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fieldsInfo2", ",", "fragmentName2", ")", "\n", "}", "\n\n", "return", "conflicts", "\n\n", "}" ]

[ "Collect", "all", "conflicts", "found", "between", "a", "set", "of", "fields", "and", "a", "fragment", "reference", "including", "via", "spreading", "in", "any", "nested", "fragments", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "collectConflictsBetweenFragments", "(", "conflicts", "[", "]", "conflict", ",", "areMutuallyExclusive", "bool", ",", "fragmentName1", "string", ",", "fragmentName2", "string", ")", "[", "]", "conflict", "{", "fragment1", ":=", "rule", ".", "context", ".", "Fragment", "(", "fragmentName1", ")", "\n", "fragment2", ":=", "rule", ".", "context", ".", "Fragment", "(", "fragmentName2", ")", "\n\n", "if", "fragment1", "==", "nil", "||", "fragment2", "==", "nil", "{", "return", "conflicts", "\n", "}", "\n\n", "// No need to compare a fragment to itself.", "if", "fragment1", "==", "fragment2", "{", "return", "conflicts", "\n", "}", "\n\n", "// Memoize so two fragments are not compared for conflicts more than once.", "if", "rule", ".", "comparedSet", ".", "Has", "(", "fragmentName1", ",", "fragmentName2", ",", "areMutuallyExclusive", ")", "{", "return", "conflicts", "\n", "}", "\n", "rule", ".", "comparedSet", ".", "Add", "(", "fragmentName1", ",", "fragmentName2", ",", "areMutuallyExclusive", ")", "\n\n", "fieldsInfo1", ":=", "rule", ".", "getReferencedFieldsAndFragmentNames", "(", "fragment1", ")", "\n", "fieldsInfo2", ":=", "rule", ".", "getReferencedFieldsAndFragmentNames", "(", "fragment2", ")", "\n\n", "// (F) First, collect all conflicts between these two collections of fields", "// (not including any nested fragments).", "conflicts", "=", "rule", ".", "collectConflictsBetween", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fieldsInfo1", ",", "fieldsInfo2", ")", "\n\n", "// (G) Then collect conflicts between the first fragment and any nested", "// fragments spread in the second fragment.", "for", "_", ",", "innerFragmentName2", ":=", "range", "fieldsInfo2", ".", "fragmentNames", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFragments", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fragmentName1", ",", "innerFragmentName2", ")", "\n", "}", "\n\n", "// (G) Then collect conflicts between the second fragment and any nested", "// fragments spread in the first fragment.", "for", "_", ",", "innerFragmentName1", ":=", "range", "fieldsInfo1", ".", "fragmentNames", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFragments", "(", "conflicts", ",", "areMutuallyExclusive", ",", "innerFragmentName1", ",", "fragmentName2", ")", "\n", "}", "\n\n", "return", "conflicts", "\n", "}" ]

[ "Collect", "all", "conflicts", "found", "between", "two", "fragments", "including", "via", "spreading", "in", "any", "nested", "fragments", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "findConflictsBetweenSubSelectionSets", "(", "areMutuallyExclusive", "bool", ",", "parentType1", "Named", ",", "selectionSet1", "*", "ast", ".", "SelectionSet", ",", "parentType2", "Named", ",", "selectionSet2", "*", "ast", ".", "SelectionSet", ")", "[", "]", "conflict", "{", "conflicts", ":=", "[", "]", "conflict", "{", "}", "\n\n", "fieldsInfo1", ":=", "rule", ".", "getFieldsAndFragmentNames", "(", "parentType1", ",", "selectionSet1", ")", "\n", "fieldsInfo2", ":=", "rule", ".", "getFieldsAndFragmentNames", "(", "parentType2", ",", "selectionSet2", ")", "\n\n", "// (H) First, collect all conflicts between these two collections of field.", "conflicts", "=", "rule", ".", "collectConflictsBetween", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fieldsInfo1", ",", "fieldsInfo2", ")", "\n\n", "// (I) Then collect conflicts between the first collection of fields and", "// those referenced by each fragment name associated with the second.", "for", "_", ",", "fragmentName2", ":=", "range", "fieldsInfo2", ".", "fragmentNames", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFieldsAndFragment", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fieldsInfo1", ",", "fragmentName2", ")", "\n", "}", "\n\n", "// (I) Then collect conflicts between the second collection of fields and", "// those referenced by each fragment name associated with the first.", "for", "_", ",", "fragmentName1", ":=", "range", "fieldsInfo1", ".", "fragmentNames", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFieldsAndFragment", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fieldsInfo2", ",", "fragmentName1", ")", "\n", "}", "\n\n", "// (J) Also collect conflicts between any fragment names by the first and", "// fragment names by the second. This compares each item in the first set of", "// names to each item in the second set of names.", "for", "_", ",", "fragmentName1", ":=", "range", "fieldsInfo1", ".", "fragmentNames", "{", "for", "_", ",", "fragmentName2", ":=", "range", "fieldsInfo2", ".", "fragmentNames", "{", "conflicts", "=", "rule", ".", "collectConflictsBetweenFragments", "(", "conflicts", ",", "areMutuallyExclusive", ",", "fragmentName1", ",", "fragmentName2", ")", "\n", "}", "\n", "}", "\n", "return", "conflicts", "\n", "}" ]

[ "Find", "all", "conflicts", "found", "between", "two", "selection", "sets", "including", "those", "found", "via", "spreading", "in", "fragments", ".", "Called", "when", "determining", "if", "conflicts", "exist", "between", "the", "sub", "-", "fields", "of", "two", "overlapping", "fields", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "collectConflictsWithin", "(", "conflicts", "[", "]", "conflict", ",", "fieldsInfo", "*", "fieldsAndFragmentNames", ")", "[", "]", "conflict", "{", "// A field map is a keyed collection, where each key represents a response", "// name and the value at that key is a list of all fields which provide that", "// response name. For every response name, if there are multiple fields, they", "// must be compared to find a potential conflict.", "for", "_", ",", "responseName", ":=", "range", "fieldsInfo", ".", "fieldsOrder", "{", "fields", ",", "ok", ":=", "fieldsInfo", ".", "fieldMap", "[", "responseName", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "// This compares every field in the list to every other field in this list", "// (except to itself). If the list only has one item, nothing needs to", "// be compared.", "if", "len", "(", "fields", ")", "<=", "1", "{", "continue", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "fields", ")", ";", "i", "++", "{", "for", "k", ":=", "i", "+", "1", ";", "k", "<", "len", "(", "fields", ")", ";", "k", "++", "{", "// within one collection is never mutually exclusive", "isMutuallyExclusive", ":=", "false", "\n", "conflict", ":=", "rule", ".", "findConflict", "(", "isMutuallyExclusive", ",", "responseName", ",", "fields", "[", "i", "]", ",", "fields", "[", "k", "]", ")", "\n", "if", "conflict", "!=", "nil", "{", "conflicts", "=", "append", "(", "conflicts", ",", "*", "conflict", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "conflicts", "\n", "}" ]

[ "Collect", "all", "Conflicts", "within", "one", "collection", "of", "fields", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "collectConflictsBetween", "(", "conflicts", "[", "]", "conflict", ",", "parentFieldsAreMutuallyExclusive", "bool", ",", "fieldsInfo1", "*", "fieldsAndFragmentNames", ",", "fieldsInfo2", "*", "fieldsAndFragmentNames", ")", "[", "]", "conflict", "{", "// A field map is a keyed collection, where each key represents a response", "// name and the value at that key is a list of all fields which provide that", "// response name. For any response name which appears in both provided field", "// maps, each field from the first field map must be compared to every field", "// in the second field map to find potential conflicts.", "for", "_", ",", "responseName", ":=", "range", "fieldsInfo1", ".", "fieldsOrder", "{", "fields1", ",", "ok1", ":=", "fieldsInfo1", ".", "fieldMap", "[", "responseName", "]", "\n", "fields2", ",", "ok2", ":=", "fieldsInfo2", ".", "fieldMap", "[", "responseName", "]", "\n", "if", "!", "ok1", "||", "!", "ok2", "{", "continue", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "fields1", ")", ";", "i", "++", "{", "for", "k", ":=", "0", ";", "k", "<", "len", "(", "fields2", ")", ";", "k", "++", "{", "conflict", ":=", "rule", ".", "findConflict", "(", "parentFieldsAreMutuallyExclusive", ",", "responseName", ",", "fields1", "[", "i", "]", ",", "fields2", "[", "k", "]", ")", "\n", "if", "conflict", "!=", "nil", "{", "conflicts", "=", "append", "(", "conflicts", ",", "*", "conflict", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "conflicts", "\n", "}" ]

[ "Collect", "all", "Conflicts", "between", "two", "collections", "of", "fields", ".", "This", "is", "similar", "to", "but", "different", "from", "the", "collectConflictsWithin", "function", "above", ".", "This", "check", "assumes", "that", "collectConflictsWithin", "has", "already", "been", "called", "on", "each", "provided", "collection", "of", "fields", ".", "This", "is", "true", "because", "this", "validator", "traverses", "each", "individual", "selection", "set", "." ]

[ "func", "(", "rule", "*", "overlappingFieldsCanBeMergedRule", ")", "findConflict", "(", "parentFieldsAreMutuallyExclusive", "bool", ",", "responseName", "string", ",", "field", "*", "fieldDefPair", ",", "field2", "*", "fieldDefPair", ")", "*", "conflict", "{", "parentType1", ":=", "field", ".", "ParentType", "\n", "ast1", ":=", "field", ".", "Field", "\n", "def1", ":=", "field", ".", "FieldDef", "\n\n", "parentType2", ":=", "field2", ".", "ParentType", "\n", "ast2", ":=", "field2", ".", "Field", "\n", "def2", ":=", "field2", ".", "FieldDef", "\n\n", "// If it is known that two fields could not possibly apply at the same", "// time, due to the parent types, then it is safe to permit them to diverge", "// in aliased field or arguments used as they will not present any ambiguity", "// by differing.", "// It is known that two parent types could never overlap if they are", "// different Object types. Interface or Union types might overlap - if not", "// in the current state of the schema, then perhaps in some future version,", "// thus may not safely diverge.", "_", ",", "isParentType1Object", ":=", "parentType1", ".", "(", "*", "Object", ")", "\n", "_", ",", "isParentType2Object", ":=", "parentType2", ".", "(", "*", "Object", ")", "\n", "areMutuallyExclusive", ":=", "parentFieldsAreMutuallyExclusive", "||", "parentType1", "!=", "parentType2", "&&", "isParentType1Object", "&&", "isParentType2Object", "\n\n", "// The return type for each field.", "var", "type1", "Type", "\n", "var", "type2", "Type", "\n", "if", "def1", "!=", "nil", "{", "type1", "=", "def1", ".", "Type", "\n", "}", "\n", "if", "def2", "!=", "nil", "{", "type2", "=", "def2", ".", "Type", "\n", "}", "\n\n", "if", "!", "areMutuallyExclusive", "{", "// Two aliases must refer to the same field.", "name1", ":=", "\"", "\"", "\n", "name2", ":=", "\"", "\"", "\n\n", "if", "ast1", ".", "Name", "!=", "nil", "{", "name1", "=", "ast1", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "ast2", ".", "Name", "!=", "nil", "{", "name2", "=", "ast2", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "name1", "!=", "name2", "{", "return", "&", "conflict", "{", "Reason", ":", "conflictReason", "{", "Name", ":", "responseName", ",", "Message", ":", "fmt", ".", "Sprintf", "(", "`%v and %v are different fields`", ",", "name1", ",", "name2", ")", ",", "}", ",", "FieldsLeft", ":", "[", "]", "ast", ".", "Node", "{", "ast1", "}", ",", "FieldsRight", ":", "[", "]", "ast", ".", "Node", "{", "ast2", "}", ",", "}", "\n", "}", "\n\n", "// Two field calls must have the same arguments.", "if", "!", "sameArguments", "(", "ast1", ".", "Arguments", ",", "ast2", ".", "Arguments", ")", "{", "return", "&", "conflict", "{", "Reason", ":", "conflictReason", "{", "Name", ":", "responseName", ",", "Message", ":", "`they have differing arguments`", ",", "}", ",", "FieldsLeft", ":", "[", "]", "ast", ".", "Node", "{", "ast1", "}", ",", "FieldsRight", ":", "[", "]", "ast", ".", "Node", "{", "ast2", "}", ",", "}", "\n", "}", "\n", "}", "\n\n", "if", "type1", "!=", "nil", "&&", "type2", "!=", "nil", "&&", "doTypesConflict", "(", "type1", ",", "type2", ")", "{", "return", "&", "conflict", "{", "Reason", ":", "conflictReason", "{", "Name", ":", "responseName", ",", "Message", ":", "fmt", ".", "Sprintf", "(", "`they return conflicting types %v and %v`", ",", "type1", ",", "type2", ")", ",", "}", ",", "FieldsLeft", ":", "[", "]", "ast", ".", "Node", "{", "ast1", "}", ",", "FieldsRight", ":", "[", "]", "ast", ".", "Node", "{", "ast2", "}", ",", "}", "\n", "}", "\n\n", "// Collect and compare sub-fields. Use the same \"visited fragment names\" list", "// for both collections so fields in a fragment reference are never", "// compared to themselves.", "selectionSet1", ":=", "ast1", ".", "SelectionSet", "\n", "selectionSet2", ":=", "ast2", ".", "SelectionSet", "\n", "if", "selectionSet1", "!=", "nil", "&&", "selectionSet2", "!=", "nil", "{", "conflicts", ":=", "rule", ".", "findConflictsBetweenSubSelectionSets", "(", "areMutuallyExclusive", ",", "GetNamed", "(", "type1", ")", ",", "selectionSet1", ",", "GetNamed", "(", "type2", ")", ",", "selectionSet2", ")", "\n", "return", "subfieldConflicts", "(", "conflicts", ",", "responseName", ",", "ast1", ",", "ast2", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "findConflict", "Determines", "if", "there", "is", "a", "conflict", "between", "two", "particular", "fields", "." ]

[ "func", "doTypesConflict", "(", "type1", "Output", ",", "type2", "Output", ")", "bool", "{", "if", "type1", ",", "ok", ":=", "type1", ".", "(", "*", "List", ")", ";", "ok", "{", "if", "type2", ",", "ok", ":=", "type2", ".", "(", "*", "List", ")", ";", "ok", "{", "return", "doTypesConflict", "(", "type1", ".", "OfType", ",", "type2", ".", "OfType", ")", "\n", "}", "\n", "return", "true", "\n", "}", "\n", "if", "type2", ",", "ok", ":=", "type2", ".", "(", "*", "List", ")", ";", "ok", "{", "if", "type1", ",", "ok", ":=", "type1", ".", "(", "*", "List", ")", ";", "ok", "{", "return", "doTypesConflict", "(", "type1", ".", "OfType", ",", "type2", ".", "OfType", ")", "\n", "}", "\n", "return", "true", "\n", "}", "\n", "if", "type1", ",", "ok", ":=", "type1", ".", "(", "*", "NonNull", ")", ";", "ok", "{", "if", "type2", ",", "ok", ":=", "type2", ".", "(", "*", "NonNull", ")", ";", "ok", "{", "return", "doTypesConflict", "(", "type1", ".", "OfType", ",", "type2", ".", "OfType", ")", "\n", "}", "\n", "return", "true", "\n", "}", "\n", "if", "type2", ",", "ok", ":=", "type2", ".", "(", "*", "NonNull", ")", ";", "ok", "{", "if", "type1", ",", "ok", ":=", "type1", ".", "(", "*", "NonNull", ")", ";", "ok", "{", "return", "doTypesConflict", "(", "type1", ".", "OfType", ",", "type2", ".", "OfType", ")", "\n", "}", "\n", "return", "true", "\n", "}", "\n", "if", "IsLeafType", "(", "type1", ")", "||", "IsLeafType", "(", "type2", ")", "{", "return", "type1", "!=", "type2", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Two", "types", "conflict", "if", "both", "types", "could", "not", "apply", "to", "a", "value", "simultaneously", ".", "Composite", "types", "are", "ignored", "as", "their", "individual", "field", "types", "will", "be", "compared", "later", "recursively", ".", "However", "List", "and", "Non", "-", "Null", "types", "must", "match", "." ]

[ "func", "subfieldConflicts", "(", "conflicts", "[", "]", "conflict", ",", "responseName", "string", ",", "ast1", "*", "ast", ".", "Field", ",", "ast2", "*", "ast", ".", "Field", ")", "*", "conflict", "{", "if", "len", "(", "conflicts", ")", ">", "0", "{", "conflictReasons", ":=", "[", "]", "conflictReason", "{", "}", "\n", "conflictFieldsLeft", ":=", "[", "]", "ast", ".", "Node", "{", "ast1", "}", "\n", "conflictFieldsRight", ":=", "[", "]", "ast", ".", "Node", "{", "ast2", "}", "\n", "for", "_", ",", "c", ":=", "range", "conflicts", "{", "conflictReasons", "=", "append", "(", "conflictReasons", ",", "c", ".", "Reason", ")", "\n", "conflictFieldsLeft", "=", "append", "(", "conflictFieldsLeft", ",", "c", ".", "FieldsLeft", "...", ")", "\n", "conflictFieldsRight", "=", "append", "(", "conflictFieldsRight", ",", "c", ".", "FieldsRight", "...", ")", "\n", "}", "\n\n", "return", "&", "conflict", "{", "Reason", ":", "conflictReason", "{", "Name", ":", "responseName", ",", "Message", ":", "conflictReasons", ",", "}", ",", "FieldsLeft", ":", "conflictFieldsLeft", ",", "FieldsRight", ":", "conflictFieldsRight", ",", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "subfieldConflicts", "Given", "a", "series", "of", "Conflicts", "which", "occurred", "between", "two", "sub", "-", "fields", "generate", "a", "single", "Conflict", "." ]

[ "func", "DefaultTypeInfoFieldDef", "(", "schema", "*", "Schema", ",", "parentType", "Type", ",", "fieldAST", "*", "ast", ".", "Field", ")", "*", "FieldDefinition", "{", "name", ":=", "\"", "\"", "\n", "if", "fieldAST", ".", "Name", "!=", "nil", "{", "name", "=", "fieldAST", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "name", "==", "SchemaMetaFieldDef", ".", "Name", "&&", "schema", ".", "QueryType", "(", ")", "==", "parentType", "{", "return", "SchemaMetaFieldDef", "\n", "}", "\n", "if", "name", "==", "TypeMetaFieldDef", ".", "Name", "&&", "schema", ".", "QueryType", "(", ")", "==", "parentType", "{", "return", "TypeMetaFieldDef", "\n", "}", "\n", "if", "name", "==", "TypeNameMetaFieldDef", ".", "Name", "&&", "parentType", "!=", "nil", "{", "if", "t", ",", "ok", ":=", "parentType", ".", "(", "*", "Object", ")", ";", "ok", "&&", "t", "!=", "nil", "{", "return", "TypeNameMetaFieldDef", "\n", "}", "\n", "if", "t", ",", "ok", ":=", "parentType", ".", "(", "*", "Interface", ")", ";", "ok", "&&", "t", "!=", "nil", "{", "return", "TypeNameMetaFieldDef", "\n", "}", "\n", "if", "t", ",", "ok", ":=", "parentType", ".", "(", "*", "Union", ")", ";", "ok", "&&", "t", "!=", "nil", "{", "return", "TypeNameMetaFieldDef", "\n", "}", "\n", "}", "\n\n", "if", "parentType", ",", "ok", ":=", "parentType", ".", "(", "*", "Object", ")", ";", "ok", "&&", "parentType", "!=", "nil", "{", "field", ",", "_", ":=", "parentType", ".", "Fields", "(", ")", "[", "name", "]", "\n", "return", "field", "\n", "}", "\n", "if", "parentType", ",", "ok", ":=", "parentType", ".", "(", "*", "Interface", ")", ";", "ok", "&&", "parentType", "!=", "nil", "{", "field", ",", "_", ":=", "parentType", ".", "Fields", "(", ")", "[", "name", "]", "\n", "return", "field", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DefaultTypeInfoFieldDef", "Not", "exactly", "the", "same", "as", "the", "executor", "s", "definition", "of", "FieldDef", "in", "this", "statically", "evaluated", "environment", "we", "do", "not", "always", "have", "an", "Object", "type", "and", "need", "to", "handle", "Interface", "and", "Union", "types", "." ]

[ "func", "NewLocatedError", "(", "err", "interface", "{", "}", ",", "nodes", "[", "]", "ast", ".", "Node", ")", "*", "Error", "{", "var", "origError", "error", "\n", "message", ":=", "\"", "\"", "\n", "if", "err", ",", "ok", ":=", "err", ".", "(", "error", ")", ";", "ok", "{", "message", "=", "err", ".", "Error", "(", ")", "\n", "origError", "=", "err", "\n", "}", "\n", "if", "err", ",", "ok", ":=", "err", ".", "(", "string", ")", ";", "ok", "{", "message", "=", "err", "\n", "origError", "=", "errors", ".", "New", "(", "err", ")", "\n", "}", "\n", "stack", ":=", "message", "\n", "return", "NewError", "(", "message", ",", "nodes", ",", "stack", ",", "nil", ",", "[", "]", "int", "{", "}", ",", "origError", ",", ")", "\n", "}" ]

[ "NewLocatedError", "creates", "a", "graphql", ".", "Error", "with", "location", "info" ]

[ "func", "importJSONDataFromFile", "(", "fileName", "string", ",", "result", "interface", "{", "}", ")", "(", "isOK", "bool", ")", "{", "isOK", "=", "true", "\n", "content", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "fileName", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Print", "(", "\"", "\"", ",", "err", ")", "\n", "isOK", "=", "false", "\n", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "content", ",", "result", ")", "\n", "if", "err", "!=", "nil", "{", "isOK", "=", "false", "\n", "fmt", ".", "Print", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Helper", "function", "to", "import", "json", "from", "file", "to", "map" ]

[ "func", "parseName", "(", "parser", "*", "Parser", ")", "(", "*", "ast", ".", "Name", ",", "error", ")", "{", "token", ",", "err", ":=", "expect", "(", "parser", ",", "lexer", ".", "NAME", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "ast", ".", "NewName", "(", "&", "ast", ".", "Name", "{", "Value", ":", "token", ".", "Value", ",", "Loc", ":", "loc", "(", "parser", ",", "token", ".", "Start", ")", ",", "}", ")", ",", "nil", "\n", "}" ]

[ "Converts", "a", "name", "lex", "token", "into", "a", "name", "parse", "node", "." ]

[ "func", "advance", "(", "parser", "*", "Parser", ")", "error", "{", "parser", ".", "PrevEnd", "=", "parser", ".", "Token", ".", "End", "\n", "token", ",", "err", ":=", "parser", ".", "LexToken", "(", "parser", ".", "PrevEnd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "parser", ".", "Token", "=", "token", "\n", "return", "nil", "\n", "}" ]

[ "Moves", "the", "internal", "parser", "object", "to", "the", "next", "lexed", "token", "." ]

[ "func", "lookahead", "(", "parser", "*", "Parser", ")", "(", "lexer", ".", "Token", ",", "error", ")", "{", "return", "parser", ".", "LexToken", "(", "parser", ".", "Token", ".", "End", ")", "\n", "}" ]

[ "lookahead", "retrieves", "the", "next", "token" ]

[ "func", "peek", "(", "parser", "*", "Parser", ",", "Kind", "lexer", ".", "TokenKind", ")", "bool", "{", "return", "parser", ".", "Token", ".", "Kind", "==", "Kind", "\n", "}" ]

[ "Determines", "if", "the", "next", "token", "is", "of", "a", "given", "kind" ]

[ "func", "peekDescription", "(", "parser", "*", "Parser", ")", "bool", "{", "return", "peek", "(", "parser", ",", "lexer", ".", "STRING", ")", "||", "peek", "(", "parser", ",", "lexer", ".", "BLOCK_STRING", ")", "\n", "}" ]

[ "peekDescription", "determines", "if", "the", "next", "token", "is", "a", "string", "value" ]

[ "func", "skip", "(", "parser", "*", "Parser", ",", "Kind", "lexer", ".", "TokenKind", ")", "(", "bool", ",", "error", ")", "{", "if", "parser", ".", "Token", ".", "Kind", "==", "Kind", "{", "return", "true", ",", "advance", "(", "parser", ")", "\n", "}", "\n", "return", "false", ",", "nil", "\n", "}" ]

[ "If", "the", "next", "token", "is", "of", "the", "given", "kind", "return", "true", "after", "advancing", "the", "parser", ".", "Otherwise", "do", "not", "change", "the", "parser", "state", "and", "return", "false", "." ]

[ "func", "expect", "(", "parser", "*", "Parser", ",", "kind", "lexer", ".", "TokenKind", ")", "(", "lexer", ".", "Token", ",", "error", ")", "{", "token", ":=", "parser", ".", "Token", "\n", "if", "token", ".", "Kind", "==", "kind", "{", "return", "token", ",", "advance", "(", "parser", ")", "\n", "}", "\n", "descp", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "kind", ",", "lexer", ".", "GetTokenDesc", "(", "token", ")", ")", "\n", "return", "token", ",", "gqlerrors", ".", "NewSyntaxError", "(", "parser", ".", "Source", ",", "token", ".", "Start", ",", "descp", ")", "\n", "}" ]

[ "If", "the", "next", "token", "is", "of", "the", "given", "kind", "return", "that", "token", "after", "advancing", "the", "parser", ".", "Otherwise", "do", "not", "change", "the", "parser", "state", "and", "return", "error", "." ]

[ "func", "expectKeyWord", "(", "parser", "*", "Parser", ",", "value", "string", ")", "(", "lexer", ".", "Token", ",", "error", ")", "{", "token", ":=", "parser", ".", "Token", "\n", "if", "token", ".", "Kind", "==", "lexer", ".", "NAME", "&&", "token", ".", "Value", "==", "value", "{", "return", "token", ",", "advance", "(", "parser", ")", "\n", "}", "\n", "descp", ":=", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "value", ",", "lexer", ".", "GetTokenDesc", "(", "token", ")", ")", "\n", "return", "token", ",", "gqlerrors", ".", "NewSyntaxError", "(", "parser", ".", "Source", ",", "token", ".", "Start", ",", "descp", ")", "\n", "}" ]

[ "If", "the", "next", "token", "is", "a", "keyword", "with", "the", "given", "value", "return", "that", "token", "after", "advancing", "the", "parser", ".", "Otherwise", "do", "not", "change", "the", "parser", "state", "and", "return", "false", "." ]

[ "func", "unexpected", "(", "parser", "*", "Parser", ",", "atToken", "lexer", ".", "Token", ")", "error", "{", "var", "token", "=", "atToken", "\n", "if", "(", "atToken", "==", "lexer", ".", "Token", "{", "}", ")", "{", "token", "=", "parser", ".", "Token", "\n", "}", "\n", "description", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "lexer", ".", "GetTokenDesc", "(", "token", ")", ")", "\n", "return", "gqlerrors", ".", "NewSyntaxError", "(", "parser", ".", "Source", ",", "token", ".", "Start", ",", "description", ")", "\n", "}" ]

[ "Helper", "function", "for", "creating", "an", "error", "when", "an", "unexpected", "lexed", "token", "is", "encountered", "." ]

[ "func", "ArgumentsOfCorrectTypeRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "Argument", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "argAST", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "Argument", ")", ";", "ok", "{", "if", "argDef", ":=", "context", ".", "Argument", "(", ")", ";", "argDef", "!=", "nil", "{", "if", "isValid", ",", "messages", ":=", "isValidLiteralValue", "(", "argDef", ".", "Type", ",", "argAST", ".", "Value", ")", ";", "!", "isValid", "{", "var", "messagesStr", ",", "argNameValue", "string", "\n", "if", "argAST", ".", "Name", "!=", "nil", "{", "argNameValue", "=", "argAST", ".", "Name", ".", "Value", "\n", "}", "\n\n", "if", "len", "(", "messages", ")", ">", "0", "{", "messagesStr", "=", "\"", "\\n", "\"", "+", "strings", ".", "Join", "(", "messages", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Argument \"%v\" has invalid value %v.%v`", ",", "argNameValue", ",", "printer", ".", "Print", "(", "argAST", ".", "Value", ")", ",", "messagesStr", ")", ",", "[", "]", "ast", ".", "Node", "{", "argAST", ".", "Value", "}", ",", ")", "\n", "}", "\n\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "ArgumentsOfCorrectTypeRule", "Argument", "values", "of", "correct", "type", "A", "GraphQL", "document", "is", "only", "valid", "if", "all", "field", "argument", "literal", "values", "are", "of", "the", "type", "expected", "by", "their", "position", "." ]

[ "func", "DefaultValuesOfCorrectTypeRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "VariableDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "varDefAST", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "VariableDefinition", ")", ";", "ok", "{", "var", "(", "name", "string", "\n", "defaultValue", "=", "varDefAST", ".", "DefaultValue", "\n", "messagesStr", "string", "\n", ")", "\n", "if", "varDefAST", ".", "Variable", "!=", "nil", "&&", "varDefAST", ".", "Variable", ".", "Name", "!=", "nil", "{", "name", "=", "varDefAST", ".", "Variable", ".", "Name", ".", "Value", "\n", "}", "\n", "ttype", ":=", "context", ".", "InputType", "(", ")", "\n\n", "// when input variable value must be nonNull, and set default value is unnecessary", "if", "ttype", ",", "ok", ":=", "ttype", ".", "(", "*", "NonNull", ")", ";", "ok", "&&", "defaultValue", "!=", "nil", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Variable \"$%v\" of type \"%v\" is required and will not use the default value. Perhaps you meant to use type \"%v\".`", ",", "name", ",", "ttype", ",", "ttype", ".", "OfType", ")", ",", "[", "]", "ast", ".", "Node", "{", "defaultValue", "}", ",", ")", "\n", "}", "\n", "if", "isValid", ",", "messages", ":=", "isValidLiteralValue", "(", "ttype", ",", "defaultValue", ")", ";", "!", "isValid", "&&", "defaultValue", "!=", "nil", "{", "if", "len", "(", "messages", ")", ">", "0", "{", "messagesStr", "=", "\"", "\\n", "\"", "+", "strings", ".", "Join", "(", "messages", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Variable \"$%v\" has invalid default value: %v.%v`", ",", "name", ",", "printer", ".", "Print", "(", "defaultValue", ")", ",", "messagesStr", ")", ",", "[", "]", "ast", ".", "Node", "{", "defaultValue", "}", ",", ")", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "SelectionSet", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "FragmentDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "DefaultValuesOfCorrectTypeRule", "Variable", "default", "values", "of", "correct", "type", "A", "GraphQL", "document", "is", "only", "valid", "if", "all", "variable", "default", "values", "are", "of", "the", "type", "expected", "by", "their", "definition", "." ]

[ "func", "getSuggestedTypeNames", "(", "schema", "*", "Schema", ",", "ttype", "Output", ",", "fieldName", "string", ")", "[", "]", "string", "{", "var", "(", "suggestedObjectTypes", "=", "[", "]", "string", "{", "}", "\n", "suggestedInterfaces", "=", "[", "]", "*", "suggestedInterface", "{", "}", "\n", "// stores a map of interface name => index in suggestedInterfaces", "suggestedInterfaceMap", "=", "map", "[", "string", "]", "int", "{", "}", "\n", "// stores a maps of object name => true to remove duplicates from results", "suggestedObjectMap", "=", "map", "[", "string", "]", "bool", "{", "}", "\n", ")", "\n", "possibleTypes", ":=", "schema", ".", "PossibleTypes", "(", "ttype", ")", "\n\n", "for", "_", ",", "possibleType", ":=", "range", "possibleTypes", "{", "if", "field", ",", "ok", ":=", "possibleType", ".", "Fields", "(", ")", "[", "fieldName", "]", ";", "!", "ok", "||", "field", "==", "nil", "{", "continue", "\n", "}", "\n", "// This object type defines this field.", "suggestedObjectTypes", "=", "append", "(", "suggestedObjectTypes", ",", "possibleType", ".", "Name", "(", ")", ")", "\n", "suggestedObjectMap", "[", "possibleType", ".", "Name", "(", ")", "]", "=", "true", "\n\n", "for", "_", ",", "possibleInterface", ":=", "range", "possibleType", ".", "Interfaces", "(", ")", "{", "if", "field", ",", "ok", ":=", "possibleInterface", ".", "Fields", "(", ")", "[", "fieldName", "]", ";", "!", "ok", "||", "field", "==", "nil", "{", "continue", "\n", "}", "\n\n", "// This interface type defines this field.", "// - find the index of the suggestedInterface and retrieving the interface", "// - increase count", "index", ",", "ok", ":=", "suggestedInterfaceMap", "[", "possibleInterface", ".", "Name", "(", ")", "]", "\n", "if", "!", "ok", "{", "suggestedInterfaces", "=", "append", "(", "suggestedInterfaces", ",", "&", "suggestedInterface", "{", "name", ":", "possibleInterface", ".", "Name", "(", ")", ",", "count", ":", "0", ",", "}", ")", "\n", "index", "=", "len", "(", "suggestedInterfaces", ")", "-", "1", "\n", "suggestedInterfaceMap", "[", "possibleInterface", ".", "Name", "(", ")", "]", "=", "index", "\n", "}", "\n", "if", "index", "<", "len", "(", "suggestedInterfaces", ")", "{", "s", ":=", "suggestedInterfaces", "[", "index", "]", "\n", "if", "s", ".", "name", "==", "possibleInterface", ".", "Name", "(", ")", "{", "s", ".", "count", "++", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// sort results (by count usage for interfaces, alphabetical order for objects)", "sort", ".", "Sort", "(", "suggestedInterfaceSortedSlice", "(", "suggestedInterfaces", ")", ")", "\n", "sort", ".", "Sort", "(", "sort", ".", "StringSlice", "(", "suggestedObjectTypes", ")", ")", "\n\n", "// return concatenated slices of both interface and object type names", "// and removing duplicates", "// ordered by: interface (sorted) and object (sorted)", "results", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "s", ":=", "range", "suggestedInterfaces", "{", "if", "_", ",", "ok", ":=", "suggestedObjectMap", "[", "s", ".", "name", "]", ";", "!", "ok", "{", "results", "=", "append", "(", "results", ",", "s", ".", "name", ")", "\n\n", "}", "\n", "}", "\n", "results", "=", "append", "(", "results", ",", "suggestedObjectTypes", "...", ")", "\n", "return", "results", "\n", "}" ]

[ "getSuggestedTypeNames", "Go", "through", "all", "of", "the", "implementations", "of", "type", "as", "well", "as", "the", "interfaces", "that", "they", "implement", ".", "If", "any", "of", "those", "types", "include", "the", "provided", "field", "suggest", "them", "sorted", "by", "how", "often", "the", "type", "is", "referenced", "starting", "with", "Interfaces", "." ]

[ "func", "getSuggestedFieldNames", "(", "schema", "*", "Schema", ",", "ttype", "Output", ",", "fieldName", "string", ")", "[", "]", "string", "{", "fields", ":=", "FieldDefinitionMap", "{", "}", "\n", "switch", "ttype", ":=", "ttype", ".", "(", "type", ")", "{", "case", "*", "Object", ":", "fields", "=", "ttype", ".", "Fields", "(", ")", "\n", "case", "*", "Interface", ":", "fields", "=", "ttype", ".", "Fields", "(", ")", "\n", "default", ":", "return", "[", "]", "string", "{", "}", "\n", "}", "\n\n", "possibleFieldNames", ":=", "[", "]", "string", "{", "}", "\n", "for", "possibleFieldName", ":=", "range", "fields", "{", "possibleFieldNames", "=", "append", "(", "possibleFieldNames", ",", "possibleFieldName", ")", "\n", "}", "\n", "return", "suggestionList", "(", "fieldName", ",", "possibleFieldNames", ")", "\n", "}" ]

[ "getSuggestedFieldNames", "For", "the", "field", "name", "provided", "determine", "if", "there", "are", "any", "similar", "field", "names", "that", "may", "be", "the", "result", "of", "a", "typo", "." ]

[ "func", "KnownArgumentNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "Argument", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "var", "action", "=", "visitor", ".", "ActionNoChange", "\n", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "Argument", ")", ";", "ok", "{", "var", "argumentOf", "ast", ".", "Node", "\n", "if", "len", "(", "p", ".", "Ancestors", ")", ">", "0", "{", "argumentOf", "=", "p", ".", "Ancestors", "[", "len", "(", "p", ".", "Ancestors", ")", "-", "1", "]", "\n", "}", "\n", "if", "argumentOf", "==", "nil", "{", "return", "action", ",", "nil", "\n", "}", "\n", "// verify node, if the node's name exists in Arguments{Field, Directive}", "var", "(", "fieldArgDef", "*", "Argument", "\n", "fieldDef", "=", "context", ".", "FieldDef", "(", ")", "\n", "directive", "=", "context", ".", "Directive", "(", ")", "\n", "argNames", "[", "]", "string", "\n", "parentTypeName", "string", "\n", ")", "\n", "switch", "argumentOf", ".", "GetKind", "(", ")", "{", "case", "kinds", ".", "Field", ":", "// get field definition", "if", "fieldDef", "==", "nil", "{", "return", "action", ",", "nil", "\n", "}", "\n", "for", "_", ",", "arg", ":=", "range", "fieldDef", ".", "Args", "{", "if", "arg", ".", "Name", "(", ")", "==", "node", ".", "Name", ".", "Value", "{", "fieldArgDef", "=", "arg", "\n", "break", "\n", "}", "\n", "argNames", "=", "append", "(", "argNames", ",", "arg", ".", "Name", "(", ")", ")", "\n", "}", "\n", "if", "fieldArgDef", "==", "nil", "{", "parentType", ":=", "context", ".", "ParentType", "(", ")", "\n", "if", "parentType", "!=", "nil", "{", "parentTypeName", "=", "parentType", ".", "Name", "(", ")", "\n", "}", "\n", "reportError", "(", "context", ",", "unknownArgMessage", "(", "node", ".", "Name", ".", "Value", ",", "fieldDef", ".", "Name", ",", "parentTypeName", ",", "suggestionList", "(", "node", ".", "Name", ".", "Value", ",", "argNames", ")", ",", ")", ",", "[", "]", "ast", ".", "Node", "{", "node", "}", ",", ")", "\n", "}", "\n", "case", "kinds", ".", "Directive", ":", "if", "directive", "=", "context", ".", "Directive", "(", ")", ";", "directive", "==", "nil", "{", "return", "action", ",", "nil", "\n", "}", "\n", "for", "_", ",", "arg", ":=", "range", "directive", ".", "Args", "{", "if", "arg", ".", "Name", "(", ")", "==", "node", ".", "Name", ".", "Value", "{", "fieldArgDef", "=", "arg", "\n", "break", "\n", "}", "\n", "argNames", "=", "append", "(", "argNames", ",", "arg", ".", "Name", "(", ")", ")", "\n", "}", "\n", "if", "fieldArgDef", "==", "nil", "{", "reportError", "(", "context", ",", "unknownDirectiveArgMessage", "(", "node", ".", "Name", ".", "Value", ",", "directive", ".", "Name", ",", "suggestionList", "(", "node", ".", "Name", ".", "Value", ",", "argNames", ")", ",", ")", ",", "[", "]", "ast", ".", "Node", "{", "node", "}", ",", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "action", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "KnownArgumentNamesRule", "Known", "argument", "names", "A", "GraphQL", "field", "is", "only", "valid", "if", "all", "supplied", "arguments", "are", "defined", "by", "that", "field", "." ]

[ "func", "KnownDirectivesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "Directive", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "var", "action", "=", "visitor", ".", "ActionNoChange", "\n", "var", "result", "interface", "{", "}", "\n", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "Directive", ")", ";", "ok", "{", "nodeName", ":=", "\"", "\"", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "nodeName", "=", "node", ".", "Name", ".", "Value", "\n", "}", "\n\n", "var", "directiveDef", "*", "Directive", "\n", "for", "_", ",", "def", ":=", "range", "context", ".", "Schema", "(", ")", ".", "Directives", "(", ")", "{", "if", "def", ".", "Name", "==", "nodeName", "{", "directiveDef", "=", "def", "\n", "}", "\n", "}", "\n", "if", "directiveDef", "==", "nil", "{", "return", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Unknown directive \"%v\".`", ",", "nodeName", ")", ",", "[", "]", "ast", ".", "Node", "{", "node", "}", ",", ")", "\n", "}", "\n\n", "candidateLocation", ":=", "getDirectiveLocationForASTPath", "(", "p", ".", "Ancestors", ")", "\n\n", "directiveHasLocation", ":=", "false", "\n", "for", "_", ",", "loc", ":=", "range", "directiveDef", ".", "Locations", "{", "if", "loc", "==", "candidateLocation", "{", "directiveHasLocation", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "candidateLocation", "==", "\"", "\"", "{", "reportError", "(", "context", ",", "MisplaceDirectiveMessage", "(", "nodeName", ",", "node", ".", "GetKind", "(", ")", ")", ",", "[", "]", "ast", ".", "Node", "{", "node", "}", ",", ")", "\n", "}", "else", "if", "!", "directiveHasLocation", "{", "reportError", "(", "context", ",", "MisplaceDirectiveMessage", "(", "nodeName", ",", "candidateLocation", ")", ",", "[", "]", "ast", ".", "Node", "{", "node", "}", ",", ")", "\n", "}", "\n\n", "}", "\n", "return", "action", ",", "result", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "KnownDirectivesRule", "Known", "directives", "A", "GraphQL", "document", "is", "only", "valid", "if", "all" ]

[ "func", "KnownFragmentNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "FragmentSpread", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "var", "action", "=", "visitor", ".", "ActionNoChange", "\n", "var", "result", "interface", "{", "}", "\n", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "FragmentSpread", ")", ";", "ok", "{", "fragmentName", ":=", "\"", "\"", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "fragmentName", "=", "node", ".", "Name", ".", "Value", "\n", "}", "\n\n", "fragment", ":=", "context", ".", "Fragment", "(", "fragmentName", ")", "\n", "if", "fragment", "==", "nil", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Unknown fragment \"%v\".`", ",", "fragmentName", ")", ",", "[", "]", "ast", ".", "Node", "{", "node", ".", "Name", "}", ",", ")", "\n", "}", "\n", "}", "\n", "return", "action", ",", "result", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "KnownFragmentNamesRule", "Known", "fragment", "names", "A", "GraphQL", "document", "is", "only", "valid", "if", "all", "...", "Fragment", "fragment", "spreads", "refer", "to", "fragments", "defined", "in", "the", "same", "document", "." ]

[ "func", "NoUndefinedVariablesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "var", "variableNameDefined", "=", "map", "[", "string", "]", "bool", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Enter", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "variableNameDefined", "=", "map", "[", "string", "]", "bool", "{", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "Leave", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "operation", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "OperationDefinition", ")", ";", "ok", "&&", "operation", "!=", "nil", "{", "usages", ":=", "context", ".", "RecursiveVariableUsages", "(", "operation", ")", "\n\n", "for", "_", ",", "usage", ":=", "range", "usages", "{", "if", "usage", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "usage", ".", "Node", "==", "nil", "{", "continue", "\n", "}", "\n", "varName", ":=", "\"", "\"", "\n", "if", "usage", ".", "Node", ".", "Name", "!=", "nil", "{", "varName", "=", "usage", ".", "Node", ".", "Name", ".", "Value", "\n", "}", "\n", "opName", ":=", "\"", "\"", "\n", "if", "operation", ".", "Name", "!=", "nil", "{", "opName", "=", "operation", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "res", ",", "ok", ":=", "variableNameDefined", "[", "varName", "]", ";", "!", "ok", "||", "!", "res", "{", "reportError", "(", "context", ",", "UndefinedVarMessage", "(", "varName", ",", "opName", ")", ",", "[", "]", "ast", ".", "Node", "{", "usage", ".", "Node", ",", "operation", "}", ",", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "VariableDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "VariableDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "variableName", ":=", "\"", "\"", "\n", "if", "node", ".", "Variable", "!=", "nil", "&&", "node", ".", "Variable", ".", "Name", "!=", "nil", "{", "variableName", "=", "node", ".", "Variable", ".", "Name", ".", "Value", "\n", "}", "\n", "variableNameDefined", "[", "variableName", "]", "=", "true", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "NoUndefinedVariablesRule", "No", "undefined", "variables", "A", "GraphQL", "operation", "is", "only", "valid", "if", "all", "variables", "encountered", "both", "directly", "and", "via", "fragment", "spreads", "are", "defined", "by", "that", "operation", "." ]

[ "func", "NoUnusedFragmentsRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "var", "fragmentDefs", "=", "[", "]", "*", "ast", ".", "FragmentDefinition", "{", "}", "\n", "var", "operationDefs", "=", "[", "]", "*", "ast", ".", "OperationDefinition", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "OperationDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "operationDefs", "=", "append", "(", "operationDefs", ",", "node", ")", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "FragmentDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "FragmentDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "fragmentDefs", "=", "append", "(", "fragmentDefs", ",", "node", ")", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "Document", ":", "{", "Leave", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "fragmentNameUsed", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "for", "_", ",", "operation", ":=", "range", "operationDefs", "{", "fragments", ":=", "context", ".", "RecursivelyReferencedFragments", "(", "operation", ")", "\n", "for", "_", ",", "fragment", ":=", "range", "fragments", "{", "fragName", ":=", "\"", "\"", "\n", "if", "fragment", ".", "Name", "!=", "nil", "{", "fragName", "=", "fragment", ".", "Name", ".", "Value", "\n", "}", "\n", "fragmentNameUsed", "[", "fragName", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "def", ":=", "range", "fragmentDefs", "{", "defName", ":=", "\"", "\"", "\n", "if", "def", ".", "Name", "!=", "nil", "{", "defName", "=", "def", ".", "Name", ".", "Value", "\n", "}", "\n\n", "isFragNameUsed", ",", "ok", ":=", "fragmentNameUsed", "[", "defName", "]", "\n", "if", "!", "ok", "||", "isFragNameUsed", "!=", "true", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Fragment \"%v\" is never used.`", ",", "defName", ")", ",", "[", "]", "ast", ".", "Node", "{", "def", "}", ",", ")", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "NoUnusedFragmentsRule", "No", "unused", "fragments", "A", "GraphQL", "document", "is", "only", "valid", "if", "all", "fragment", "definitions", "are", "spread", "within", "operations", "or", "spread", "within", "other", "fragments", "spread", "within", "operations", "." ]

[ "func", "NoUnusedVariablesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "var", "variableDefs", "=", "[", "]", "*", "ast", ".", "VariableDefinition", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Enter", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "variableDefs", "=", "[", "]", "*", "ast", ".", "VariableDefinition", "{", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "Leave", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "operation", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "OperationDefinition", ")", ";", "ok", "&&", "operation", "!=", "nil", "{", "variableNameUsed", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "usages", ":=", "context", ".", "RecursiveVariableUsages", "(", "operation", ")", "\n\n", "for", "_", ",", "usage", ":=", "range", "usages", "{", "varName", ":=", "\"", "\"", "\n", "if", "usage", "!=", "nil", "&&", "usage", ".", "Node", "!=", "nil", "&&", "usage", ".", "Node", ".", "Name", "!=", "nil", "{", "varName", "=", "usage", ".", "Node", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "varName", "!=", "\"", "\"", "{", "variableNameUsed", "[", "varName", "]", "=", "true", "\n", "}", "\n", "}", "\n", "for", "_", ",", "variableDef", ":=", "range", "variableDefs", "{", "variableName", ":=", "\"", "\"", "\n", "if", "variableDef", "!=", "nil", "&&", "variableDef", ".", "Variable", "!=", "nil", "&&", "variableDef", ".", "Variable", ".", "Name", "!=", "nil", "{", "variableName", "=", "variableDef", ".", "Variable", ".", "Name", ".", "Value", "\n", "}", "\n", "opName", ":=", "\"", "\"", "\n", "if", "operation", ".", "Name", "!=", "nil", "{", "opName", "=", "operation", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "res", ",", "ok", ":=", "variableNameUsed", "[", "variableName", "]", ";", "!", "ok", "||", "!", "res", "{", "reportError", "(", "context", ",", "UnusedVariableMessage", "(", "variableName", ",", "opName", ")", ",", "[", "]", "ast", ".", "Node", "{", "variableDef", "}", ",", ")", "\n", "}", "\n", "}", "\n\n", "}", "\n\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "VariableDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "def", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "VariableDefinition", ")", ";", "ok", "&&", "def", "!=", "nil", "{", "variableDefs", "=", "append", "(", "variableDefs", ",", "def", ")", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "NoUnusedVariablesRule", "No", "unused", "variables", "A", "GraphQL", "operation", "is", "only", "valid", "if", "all", "variables", "defined", "by", "an", "operation", "are", "used", "either", "directly", "or", "within", "a", "spread", "fragment", "." ]

[ "func", "UniqueArgumentNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "knownArgNames", ":=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "Field", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "knownArgNames", "=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "Directive", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "knownArgNames", "=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "Argument", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "Argument", ")", ";", "ok", "{", "argName", ":=", "\"", "\"", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "argName", "=", "node", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "nameAST", ",", "ok", ":=", "knownArgNames", "[", "argName", "]", ";", "ok", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`There can be only one argument named \"%v\".`", ",", "argName", ")", ",", "[", "]", "ast", ".", "Node", "{", "nameAST", ",", "node", ".", "Name", "}", ",", ")", "\n", "}", "else", "{", "knownArgNames", "[", "argName", "]", "=", "node", ".", "Name", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "UniqueArgumentNamesRule", "Unique", "argument", "names", "A", "GraphQL", "field", "or", "directive", "is", "only", "valid", "if", "all", "supplied", "arguments", "are", "uniquely", "named", "." ]

[ "func", "UniqueFragmentNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "knownFragmentNames", ":=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "FragmentDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "FragmentDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "fragmentName", ":=", "\"", "\"", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "fragmentName", "=", "node", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "nameAST", ",", "ok", ":=", "knownFragmentNames", "[", "fragmentName", "]", ";", "ok", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`There can only be one fragment named \"%v\".`", ",", "fragmentName", ")", ",", "[", "]", "ast", ".", "Node", "{", "nameAST", ",", "node", ".", "Name", "}", ",", ")", "\n", "}", "else", "{", "knownFragmentNames", "[", "fragmentName", "]", "=", "node", ".", "Name", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "UniqueFragmentNamesRule", "Unique", "fragment", "names", "A", "GraphQL", "document", "is", "only", "valid", "if", "all", "defined", "fragments", "have", "unique", "names", "." ]

[ "func", "UniqueInputFieldNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "knownNameStack", ":=", "[", "]", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n", "knownNames", ":=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "ObjectValue", ":", "{", "Enter", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "knownNameStack", "=", "append", "(", "knownNameStack", ",", "knownNames", ")", "\n", "knownNames", "=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "Leave", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "// pop", "knownNames", ",", "knownNameStack", "=", "knownNameStack", "[", "len", "(", "knownNameStack", ")", "-", "1", "]", ",", "knownNameStack", "[", ":", "len", "(", "knownNameStack", ")", "-", "1", "]", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "ObjectField", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "ObjectField", ")", ";", "ok", "{", "fieldName", ":=", "\"", "\"", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "fieldName", "=", "node", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "knownNameAST", ",", "ok", ":=", "knownNames", "[", "fieldName", "]", ";", "ok", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`There can be only one input field named \"%v\".`", ",", "fieldName", ")", ",", "[", "]", "ast", ".", "Node", "{", "knownNameAST", ",", "node", ".", "Name", "}", ",", ")", "\n", "}", "else", "{", "knownNames", "[", "fieldName", "]", "=", "node", ".", "Name", "\n", "}", "\n\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "UniqueInputFieldNamesRule", "Unique", "input", "field", "names", "A", "GraphQL", "input", "object", "value", "is", "only", "valid", "if", "all", "supplied", "fields", "are", "uniquely", "named", "." ]

[ "func", "UniqueOperationNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "knownOperationNames", ":=", "make", "(", "map", "[", "string", "]", "ast", ".", "Node", ")", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "OperationDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "operationName", ":=", "\"", "\"", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "operationName", "=", "node", ".", "Name", ".", "Value", "\n", "}", "\n", "var", "errNode", "ast", ".", "Node", "=", "node", "\n", "if", "node", ".", "Name", "!=", "nil", "{", "errNode", "=", "node", ".", "Name", "\n", "}", "\n", "if", "nameAST", ",", "ok", ":=", "knownOperationNames", "[", "operationName", "]", ";", "ok", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`There can only be one operation named \"%v\".`", ",", "operationName", ")", ",", "[", "]", "ast", ".", "Node", "{", "nameAST", ",", "errNode", "}", ",", ")", "\n", "}", "else", "{", "knownOperationNames", "[", "operationName", "]", "=", "errNode", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "FragmentDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "return", "visitor", ".", "ActionSkip", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "UniqueOperationNamesRule", "Unique", "operation", "names", "A", "GraphQL", "document", "is", "only", "valid", "if", "all", "defined", "operations", "have", "unique", "names", "." ]

[ "func", "UniqueVariableNamesRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "knownVariableNames", ":=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "OperationDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "knownVariableNames", "=", "map", "[", "string", "]", "*", "ast", ".", "Name", "{", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "VariableDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "VariableDefinition", ")", ";", "ok", "&&", "node", "!=", "nil", "{", "variableName", ":=", "\"", "\"", "\n", "var", "variableNameAST", "*", "ast", ".", "Name", "\n", "if", "node", ".", "Variable", "!=", "nil", "&&", "node", ".", "Variable", ".", "Name", "!=", "nil", "{", "variableNameAST", "=", "node", ".", "Variable", ".", "Name", "\n", "variableName", "=", "node", ".", "Variable", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "nameAST", ",", "ok", ":=", "knownVariableNames", "[", "variableName", "]", ";", "ok", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`There can only be one variable named \"%v\".`", ",", "variableName", ")", ",", "[", "]", "ast", ".", "Node", "{", "nameAST", ",", "variableNameAST", "}", ",", ")", "\n", "}", "else", "{", "knownVariableNames", "[", "variableName", "]", "=", "variableNameAST", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "UniqueVariableNamesRule", "Unique", "variable", "names", "A", "GraphQL", "operation", "is", "only", "valid", "if", "all", "its", "variables", "are", "uniquely", "named", "." ]

[ "func", "effectiveType", "(", "varType", "Type", ",", "varDef", "*", "ast", ".", "VariableDefinition", ")", "Type", "{", "if", "varDef", ".", "DefaultValue", "==", "nil", "{", "return", "varType", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "varType", ".", "(", "*", "NonNull", ")", ";", "ok", "{", "return", "varType", "\n", "}", "\n", "return", "NewNonNull", "(", "varType", ")", "\n", "}" ]

[ "If", "a", "variable", "definition", "has", "a", "default", "value", "it", "s", "effectively", "non", "-", "null", "." ]

[ "func", "VariablesInAllowedPositionRule", "(", "context", "*", "ValidationContext", ")", "*", "ValidationRuleInstance", "{", "varDefMap", ":=", "map", "[", "string", "]", "*", "ast", ".", "VariableDefinition", "{", "}", "\n\n", "visitorOpts", ":=", "&", "visitor", ".", "VisitorOptions", "{", "KindFuncMap", ":", "map", "[", "string", "]", "visitor", ".", "NamedVisitFuncs", "{", "kinds", ".", "OperationDefinition", ":", "{", "Enter", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "varDefMap", "=", "map", "[", "string", "]", "*", "ast", ".", "VariableDefinition", "{", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "Leave", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "operation", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "OperationDefinition", ")", ";", "ok", "{", "usages", ":=", "context", ".", "RecursiveVariableUsages", "(", "operation", ")", "\n", "for", "_", ",", "usage", ":=", "range", "usages", "{", "varName", ":=", "\"", "\"", "\n", "if", "usage", "!=", "nil", "&&", "usage", ".", "Node", "!=", "nil", "&&", "usage", ".", "Node", ".", "Name", "!=", "nil", "{", "varName", "=", "usage", ".", "Node", ".", "Name", ".", "Value", "\n", "}", "\n", "varDef", ",", "_", ":=", "varDefMap", "[", "varName", "]", "\n", "if", "varDef", "!=", "nil", "&&", "usage", ".", "Type", "!=", "nil", "{", "varType", ",", "err", ":=", "typeFromAST", "(", "*", "context", ".", "Schema", "(", ")", ",", "varDef", ".", "Type", ")", "\n", "if", "err", "!=", "nil", "{", "varType", "=", "nil", "\n", "}", "\n", "if", "varType", "!=", "nil", "&&", "!", "isTypeSubTypeOf", "(", "context", ".", "Schema", "(", ")", ",", "effectiveType", "(", "varType", ",", "varDef", ")", ",", "usage", ".", "Type", ")", "{", "reportError", "(", "context", ",", "fmt", ".", "Sprintf", "(", "`Variable \"$%v\" of type \"%v\" used in position `", "+", "`expecting type \"%v\".`", ",", "varName", ",", "varType", ",", "usage", ".", "Type", ")", ",", "[", "]", "ast", ".", "Node", "{", "varDef", ",", "usage", ".", "Node", "}", ",", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "kinds", ".", "VariableDefinition", ":", "{", "Kind", ":", "func", "(", "p", "visitor", ".", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "varDefAST", ",", "ok", ":=", "p", ".", "Node", ".", "(", "*", "ast", ".", "VariableDefinition", ")", ";", "ok", "{", "defName", ":=", "\"", "\"", "\n", "if", "varDefAST", ".", "Variable", "!=", "nil", "&&", "varDefAST", ".", "Variable", ".", "Name", "!=", "nil", "{", "defName", "=", "varDefAST", ".", "Variable", ".", "Name", ".", "Value", "\n", "}", "\n", "if", "defName", "!=", "\"", "\"", "{", "varDefMap", "[", "defName", "]", "=", "varDefAST", "\n", "}", "\n", "}", "\n", "return", "visitor", ".", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", ",", "}", ",", "}", "\n", "return", "&", "ValidationRuleInstance", "{", "VisitorOpts", ":", "visitorOpts", ",", "}", "\n", "}" ]

[ "VariablesInAllowedPositionRule", "Variables", "passed", "to", "field", "arguments", "conform", "to", "type" ]

[ "func", "suggestionList", "(", "input", "string", ",", "options", "[", "]", "string", ")", "[", "]", "string", "{", "dists", ":=", "[", "]", "float64", "{", "}", "\n", "filteredOpts", ":=", "[", "]", "string", "{", "}", "\n", "inputThreshold", ":=", "float64", "(", "len", "(", "input", ")", "/", "2", ")", "\n\n", "for", "_", ",", "opt", ":=", "range", "options", "{", "dist", ":=", "lexicalDistance", "(", "input", ",", "opt", ")", "\n", "threshold", ":=", "math", ".", "Max", "(", "inputThreshold", ",", "float64", "(", "len", "(", "opt", ")", "/", "2", ")", ")", "\n", "threshold", "=", "math", ".", "Max", "(", "threshold", ",", "1", ")", "\n", "if", "dist", "<=", "threshold", "{", "filteredOpts", "=", "append", "(", "filteredOpts", ",", "opt", ")", "\n", "dists", "=", "append", "(", "dists", ",", "dist", ")", "\n", "}", "\n", "}", "\n", "//sort results", "suggested", ":=", "suggestionListResult", "{", "filteredOpts", ",", "dists", "}", "\n", "sort", ".", "Sort", "(", "suggested", ")", "\n", "return", "suggested", ".", "Options", "\n", "}" ]

[ "suggestionList", "Given", "an", "invalid", "input", "string", "and", "a", "list", "of", "valid", "options", "returns", "a", "filtered", "list", "of", "valid", "options", "sorted", "based", "on", "their", "similarity", "with", "the", "input", "." ]

[ "func", "lexicalDistance", "(", "a", ",", "b", "string", ")", "float64", "{", "d", ":=", "[", "]", "[", "]", "float64", "{", "}", "\n", "aLen", ":=", "len", "(", "a", ")", "\n", "bLen", ":=", "len", "(", "b", ")", "\n", "for", "i", ":=", "0", ";", "i", "<=", "aLen", ";", "i", "++", "{", "d", "=", "append", "(", "d", ",", "[", "]", "float64", "{", "float64", "(", "i", ")", "}", ")", "\n", "}", "\n", "for", "k", ":=", "1", ";", "k", "<=", "bLen", ";", "k", "++", "{", "d", "[", "0", "]", "=", "append", "(", "d", "[", "0", "]", ",", "float64", "(", "k", ")", ")", "\n", "}", "\n\n", "for", "i", ":=", "1", ";", "i", "<=", "aLen", ";", "i", "++", "{", "for", "k", ":=", "1", ";", "k", "<=", "bLen", ";", "k", "++", "{", "cost", ":=", "1.0", "\n", "if", "a", "[", "i", "-", "1", "]", "==", "b", "[", "k", "-", "1", "]", "{", "cost", "=", "0.0", "\n", "}", "\n", "minCostFloat", ":=", "math", ".", "Min", "(", "d", "[", "i", "-", "1", "]", "[", "k", "]", "+", "1.0", ",", "d", "[", "i", "]", "[", "k", "-", "1", "]", "+", "1.0", ",", ")", "\n", "minCostFloat", "=", "math", ".", "Min", "(", "minCostFloat", ",", "d", "[", "i", "-", "1", "]", "[", "k", "-", "1", "]", "+", "cost", ",", ")", "\n", "d", "[", "i", "]", "=", "append", "(", "d", "[", "i", "]", ",", "minCostFloat", ")", "\n\n", "if", "i", ">", "1", "&&", "k", "<", "1", "&&", "a", "[", "i", "-", "1", "]", "==", "b", "[", "k", "-", "2", "]", "&&", "a", "[", "i", "-", "2", "]", "==", "b", "[", "k", "-", "1", "]", "{", "d", "[", "i", "]", "[", "k", "]", "=", "math", ".", "Min", "(", "d", "[", "i", "]", "[", "k", "]", ",", "d", "[", "i", "-", "2", "]", "[", "k", "-", "2", "]", "+", "cost", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "d", "[", "aLen", "]", "[", "bLen", "]", "\n", "}" ]

[ "lexicalDistance", "Computes", "the", "lexical", "distance", "between", "strings", "A", "and", "B", ".", "The", "distance", "between", "two", "strings", "is", "given", "by", "counting", "the", "minimum", "number", "of", "edits", "needed", "to", "transform", "string", "A", "into", "string", "B", ".", "An", "edit", "can", "be", "an", "insertion", "deletion", "or", "substitution", "of", "a", "single", "character", "or", "a", "swap", "of", "two", "adjacent", "characters", ".", "This", "distance", "can", "be", "useful", "for", "detecting", "typos", "in", "input", "or", "sorting" ]

[ "func", "BindArg", "(", "obj", "interface", "{", "}", ",", "tags", "...", "string", ")", "FieldConfigArgument", "{", "v", ":=", "reflect", ".", "Indirect", "(", "reflect", ".", "ValueOf", "(", "obj", ")", ")", "\n", "var", "config", "=", "make", "(", "FieldConfigArgument", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "v", ".", "NumField", "(", ")", ";", "i", "++", "{", "field", ":=", "v", ".", "Type", "(", ")", ".", "Field", "(", "i", ")", "\n\n", "mytag", ":=", "extractTag", "(", "field", ".", "Tag", ")", "\n", "if", "inArray", "(", "tags", ",", "mytag", ")", "{", "config", "[", "mytag", "]", "=", "&", "ArgumentConfig", "{", "Type", ":", "getGraphType", "(", "field", ".", "Type", ")", ",", "}", "\n", "}", "\n", "}", "\n", "return", "config", "\n", "}" ]

[ "lazy", "way", "of", "binding", "args" ]

[ "func", "updateNodeField", "(", "src", "interface", "{", "}", ",", "targetName", "string", ",", "target", "interface", "{", "}", ")", "interface", "{", "}", "{", "var", "isPtr", "bool", "\n", "srcVal", ":=", "reflect", ".", "ValueOf", "(", "src", ")", "\n", "// verify condition", "if", "srcVal", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "isPtr", "=", "true", "\n", "srcVal", "=", "srcVal", ".", "Elem", "(", ")", "\n", "}", "\n", "targetVal", ":=", "reflect", ".", "ValueOf", "(", "target", ")", "\n", "if", "srcVal", ".", "Kind", "(", ")", "!=", "reflect", ".", "Struct", "{", "return", "src", "\n", "}", "\n", "srcFieldValue", ":=", "srcVal", ".", "FieldByName", "(", "targetName", ")", "\n", "if", "!", "srcFieldValue", ".", "IsValid", "(", ")", "||", "srcFieldValue", ".", "Kind", "(", ")", "!=", "targetVal", ".", "Kind", "(", ")", "{", "return", "src", "\n", "}", "\n\n", "if", "srcFieldValue", ".", "CanSet", "(", ")", "{", "if", "srcFieldValue", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "{", "items", ":=", "reflect", ".", "MakeSlice", "(", "srcFieldValue", ".", "Type", "(", ")", ",", "targetVal", ".", "Len", "(", ")", ",", "targetVal", ".", "Len", "(", ")", ")", "\n", "for", "index", ":=", "0", ";", "index", "<", "items", ".", "Len", "(", ")", ";", "index", "++", "{", "tmp", ":=", "targetVal", ".", "Index", "(", "index", ")", ".", "Interface", "(", ")", "\n", "items", ".", "Index", "(", "index", ")", ".", "Set", "(", "reflect", ".", "ValueOf", "(", "tmp", ")", ")", "\n", "}", "\n", "srcFieldValue", ".", "Set", "(", "items", ")", "\n", "}", "else", "{", "srcFieldValue", ".", "Set", "(", "targetVal", ")", "\n", "}", "\n", "}", "\n", "if", "isPtr", "{", "return", "srcVal", ".", "Addr", "(", ")", ".", "Interface", "(", ")", "\n", "}", "\n", "return", "srcVal", ".", "Interface", "(", ")", "\n", "}" ]

[ "currently", "only", "supports", "update", "struct", "field", "value" ]

[ "func", "VisitInParallel", "(", "visitorOptsSlice", "...", "*", "VisitorOptions", ")", "*", "VisitorOptions", "{", "skipping", ":=", "map", "[", "int", "]", "interface", "{", "}", "{", "}", "\n\n", "return", "&", "VisitorOptions", "{", "Enter", ":", "func", "(", "p", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "for", "i", ",", "visitorOpts", ":=", "range", "visitorOptsSlice", "{", "if", "_", ",", "ok", ":=", "skipping", "[", "i", "]", ";", "!", "ok", "{", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "ast", ".", "Node", ")", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "kind", ":=", "node", ".", "GetKind", "(", ")", "\n", "fn", ":=", "GetVisitFn", "(", "visitorOpts", ",", "kind", ",", "false", ")", "\n", "if", "fn", "!=", "nil", "{", "action", ",", "result", ":=", "fn", "(", "p", ")", "\n", "if", "action", "==", "ActionSkip", "{", "skipping", "[", "i", "]", "=", "node", "\n", "}", "else", "if", "action", "==", "ActionBreak", "{", "skipping", "[", "i", "]", "=", "ActionBreak", "\n", "}", "else", "if", "action", "==", "ActionUpdate", "{", "return", "ActionUpdate", ",", "result", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "ActionNoChange", ",", "nil", "\n", "}", ",", "Leave", ":", "func", "(", "p", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "for", "i", ",", "visitorOpts", ":=", "range", "visitorOptsSlice", "{", "skippedNode", ",", "ok", ":=", "skipping", "[", "i", "]", "\n", "if", "!", "ok", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "ast", ".", "Node", ")", ";", "ok", "{", "kind", ":=", "node", ".", "GetKind", "(", ")", "\n", "fn", ":=", "GetVisitFn", "(", "visitorOpts", ",", "kind", ",", "true", ")", "\n", "if", "fn", "!=", "nil", "{", "action", ",", "result", ":=", "fn", "(", "p", ")", "\n", "if", "action", "==", "ActionBreak", "{", "skipping", "[", "i", "]", "=", "ActionBreak", "\n", "}", "else", "if", "action", "==", "ActionUpdate", "{", "return", "ActionUpdate", ",", "result", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "else", "if", "skippedNode", "==", "p", ".", "Node", "{", "delete", "(", "skipping", ",", "i", ")", "\n", "}", "\n", "}", "\n", "return", "ActionNoChange", ",", "nil", "\n", "}", ",", "}", "\n", "}" ]

[ "VisitInParallel", "Creates", "a", "new", "visitor", "instance", "which", "delegates", "to", "many", "visitors", "to", "run", "in", "parallel", ".", "Each", "visitor", "will", "be", "visited", "for", "each", "node", "before", "moving", "on", ".", "If", "a", "prior", "visitor", "edits", "a", "node", "no", "following", "visitors", "will", "see", "that", "node", "." ]

[ "func", "VisitWithTypeInfo", "(", "ttypeInfo", "typeInfo", ".", "TypeInfoI", ",", "visitorOpts", "*", "VisitorOptions", ")", "*", "VisitorOptions", "{", "return", "&", "VisitorOptions", "{", "Enter", ":", "func", "(", "p", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "ast", ".", "Node", ")", ";", "ok", "{", "ttypeInfo", ".", "Enter", "(", "node", ")", "\n", "fn", ":=", "GetVisitFn", "(", "visitorOpts", ",", "node", ".", "GetKind", "(", ")", ",", "false", ")", "\n", "if", "fn", "!=", "nil", "{", "action", ",", "result", ":=", "fn", "(", "p", ")", "\n", "if", "action", "==", "ActionUpdate", "{", "ttypeInfo", ".", "Leave", "(", "node", ")", "\n", "if", "isNode", "(", "result", ")", "{", "if", "result", ",", "ok", ":=", "result", ".", "(", "ast", ".", "Node", ")", ";", "ok", "{", "ttypeInfo", ".", "Enter", "(", "result", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "action", ",", "result", "\n", "}", "\n", "}", "\n", "return", "ActionNoChange", ",", "nil", "\n", "}", ",", "Leave", ":", "func", "(", "p", "VisitFuncParams", ")", "(", "string", ",", "interface", "{", "}", ")", "{", "action", ":=", "ActionNoChange", "\n", "var", "result", "interface", "{", "}", "\n", "if", "node", ",", "ok", ":=", "p", ".", "Node", ".", "(", "ast", ".", "Node", ")", ";", "ok", "{", "fn", ":=", "GetVisitFn", "(", "visitorOpts", ",", "node", ".", "GetKind", "(", ")", ",", "true", ")", "\n", "if", "fn", "!=", "nil", "{", "action", ",", "result", "=", "fn", "(", "p", ")", "\n", "}", "\n", "ttypeInfo", ".", "Leave", "(", "node", ")", "\n", "}", "\n", "return", "action", ",", "result", "\n", "}", ",", "}", "\n", "}" ]

[ "VisitWithTypeInfo", "Creates", "a", "new", "visitor", "instance", "which", "maintains", "a", "provided", "TypeInfo", "instance", "along", "with", "visiting", "visitor", "." ]

[ "func", "readDigits", "(", "s", "*", "source", ".", "Source", ",", "start", "int", ",", "firstCode", "rune", ",", "codeLength", "int", ")", "(", "int", ",", "error", ")", "{", "body", ":=", "s", ".", "Body", "\n", "position", ":=", "start", "\n", "code", ":=", "firstCode", "\n", "if", "code", ">=", "'0'", "&&", "code", "<=", "'9'", "{", "// 0 - 9", "for", "{", "if", "code", ">=", "'0'", "&&", "code", "<=", "'9'", "{", "// 0 - 9", "position", "+=", "codeLength", "\n", "code", ",", "codeLength", "=", "runeAt", "(", "body", ",", "position", ")", "\n", "continue", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n", "return", "position", ",", "nil", "\n", "}", "\n", "var", "description", "string", "\n", "description", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "printCharCode", "(", "code", ")", ")", "\n", "return", "position", ",", "gqlerrors", ".", "NewSyntaxError", "(", "s", ",", "position", ",", "description", ")", "\n", "}" ]

[ "Returns", "the", "new", "position", "in", "the", "source", "after", "reading", "digits", "." ]

[ "func", "leadingWhitespaceLen", "(", "in", "string", ")", "(", "n", "int", ")", "{", "for", "_", ",", "ch", ":=", "range", "in", "{", "if", "ch", "==", "' '", "||", "ch", "==", "'\\t'", "{", "n", "++", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "leadingWhitespaceLen", "returns", "count", "of", "whitespace", "characters", "on", "given", "line", "." ]