Creates a declaration object for the field identified by the given identifier
on the give pattern object
185286
protected static Declaration createDeclarationObject(final RuleBuildContext context,
                                                         final String identifier,
                                                         final Pattern pattern) {
        return createDeclarationObject(context, identifier, identifier, pattern);
    }
659669
function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) {
            var members = ts.createMap();
            var hasComputedProperties = false;
            ts.forEach(pattern.elements, function (e) {
                var name = e.propertyName || e.name;
                if (isComputedNonLiteralName(name)) {
                    // do not include computed properties in the implied type
                    hasComputedProperties = true;
                    return;
                }
                var text = getTextOfPropertyName(name);
                var flags = 4 /* Property */ | 67108864 /* Transient */ | (e.initializer ? 536870912 /* Optional */ : 0);
                var symbol = createSymbol(flags, text);
                symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
                symbol.bindingElement = e;
                members[symbol.name] = symbol;
            });
            var result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined);
            if (includePatternInType) {
                result.pattern = pattern;
            }
            if (hasComputedProperties) {
                result.flags |= 536870912 /* ObjectLiteralPatternWithComputedProperties */;
            }
            return result;
        }
1103605
private IdentifierImpl createIdentifierForSubExpression(String subExpression,
                                                          String fullExpression,
                                                          boolean isLocationStep,
                                                          boolean isLastStep) 
    throws InvalidXPathSyntaxException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(cclass,
               "createIdentifierForSubExpression",
               "subExpression: " + subExpression + ", isLocStep: " + 
               new Boolean(isLocationStep) + ", isLastStep: " + 
               new Boolean(isLocationStep));
    
    IdentifierImpl stepIdentifier = new IdentifierImpl(subExpression); 
    // Set the full name into the identifier
    stepIdentifier.setFullName(fullExpression);
    
    // bump the locationStep if we're not dealing with a predicate
    if(isLocationStep)
      locationStep++;
    
    // Set the appropriate XPath parameters for this Identifier
    setXPathCharacteristics(stepIdentifier);
    
    // Set the type to child if not the last step
    if(!isLastStep)
      stepIdentifier.setType(Selector.CHILD);
    else
      stepIdentifier.setType(Selector.BOOLEAN);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "createIdentifierForSubExpression", stepIdentifier);   
    return stepIdentifier;
  }
1299426
function (identifier, field, values) {
            var self = this;
            return this.needByIdentifier(identifier).then(function (record) {
                return self.addFieldIfNotExistById(record.id, field, values);
            });
        }
744686
public FunctionDeclaration createDeclaration(
      ImportStack importStack, Context context, Object object, Method method
  ) {
    StringBuilder signature = new StringBuilder();
    Parameter[] parameters = method.getParameters();

    List<ArgumentConverter> argumentConverters = new ArrayList<>(method.getParameterCount());
    signature.append(method.getName()).append("(");

    int parameterCount = 0;
    for (Parameter parameter : parameters) {
      ArgumentConverter argumentConverter = createArgumentConverter(object, method, parameter);

      argumentConverters.add(argumentConverter);

      List<FunctionArgumentSignature> list = argumentConverter.argumentSignatures(
          object,
          method,
          parameter,
          functionArgumentSignatureFactory
      );

      for (FunctionArgumentSignature functionArgumentSignature : list) {
        String name = functionArgumentSignature.getName();
        Object defaultValue = functionArgumentSignature.getDefaultValue();

        if (parameterCount > 0) {
          signature.append(", ");
        }

        signature.append("$").append(name);

        if (null != defaultValue) {
          signature.append(": ").append(formatDefaultValue(defaultValue));
        }

        parameterCount++;
      }
    }

    signature.append(")");

    // Overwrite signature with special ones
    if (method.isAnnotationPresent(WarnFunction.class)) {
      signature.setLength(0);
      signature.append("@warn");
    } else if (method.isAnnotationPresent(ErrorFunction.class)) {
      signature.setLength(0);
      signature.append("@error");
    } else if (method.isAnnotationPresent(DebugFunction.class)) {
      signature.setLength(0);
      signature.append("@debug");
    }

    return new FunctionDeclaration(
        importStack,
        context,
        signature.toString(),
        object,
        method,
        argumentConverters
    );
  }
1348741
function (identifier, obj) {
        var legal = true;
        if (_cs.istypeof(_cs.state_methods) === "function") {
            var stateMethods = _cs.state_methods();
            var wrongFields = [];
            for (var field in obj) {
                if (   _cs.isown(obj, field)
                    && stateMethods[field]) {
                    legal = false;
                    wrongFields.push("\"" + field + "\"");
                }
            }
            if (!legal)
                throw _cs.exception("clazz_or_trait", "definition of \"" + identifier +
                    "\" failed. You can not redefine state transition functions named " +
                    wrongFields.join(", "));
        }
        return legal;
    }
736190
function (fieldDefinition) {
		let type = fieldDefinition.fieldType;
		if (typeof type === 'object') {
			type = fieldDefinition.fieldType.type;
		}
		return type;
	}
1118467
def resolve(identifier)
      return identifier if identifier.is_a?(Class)
      if constant = identifiers[identifier]
        return constant
      end

      constant = resolve_class(identifier)
      unless constant
        constant = resolve_identifier(identifier)
      end
      identifiers[identifier] = constant
    end
1104410
function parseVariableIdentifier() {
        var token, startToken;

        startToken = lookahead;
        token = lex();

        if (token.type !== Token.Identifier) {
            throwUnexpected(token);
        }

        return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
    }
233661
def _handle_identifier_type(self, node, scope, ctxt, stream):
        
        self._dlog("handling identifier")

        cls = self._resolve_to_field_class(node.names, scope)
        return cls
556252
def declare_array(self, id_, lineno, type_, bounds, default_value=None):
        
        assert isinstance(type_, symbols.TYPEREF)
        assert isinstance(bounds, symbols.BOUNDLIST)

        if not self.check_class(id_, CLASS.array, lineno, scope=self.current_scope):
            return None

        entry = self.get_entry(id_, self.current_scope)
        if entry is None:
            entry = self.declare(id_, lineno, symbols.VARARRAY(id_, bounds, lineno, type_=type_))

        if not entry.declared:
            if entry.callable:
                syntax_error(lineno,
                             "Array '%s' must be declared before use. "
                             "First used at line %i" %
                             (id_, entry.lineno))
                return None
        else:
            if entry.scope == SCOPE.parameter:
                syntax_error(lineno, "variable '%s' already declared as a "
                                     "parameter at line %i" % (id_, entry.lineno))
            else:
                syntax_error(lineno, "variable '%s' already declared at "
                                     "line %i" % (id_, entry.lineno))
            return None

        if entry.type_ != self.basic_types[TYPE.unknown] and entry.type_ != type_:
            if not type_.implicit:
                syntax_error(lineno, "Array suffix for '%s' is for type '%s' "
                                     "but declared as '%s'" %
                             (entry.name, entry.type_, type_))
                return None

            type_.implicit = False
            type_ = entry.type_

        if type_.implicit:
            warning_implicit_type(lineno, id_, type_)

        if not isinstance(entry, symbols.VARARRAY):
            entry = symbols.VAR.to_vararray(entry, bounds)

        entry.declared = True
        entry.type_ = type_
        entry.scope = SCOPE.global_ if self.current_scope == self.global_scope else SCOPE.local
        entry.default_value = default_value
        entry.callable = True
        entry.class_ = CLASS.array
        entry.lbound_used = entry.ubound_used = False  # Flag to true when LBOUND/UBOUND used somewhere in the code

        __DEBUG__('Entry %s declared with class %s at scope %i' % (id_, CLASS.to_string(entry.class_),
                                                                   self.current_scope))
        return entry
212960
protected void buildField( ClassVisitor cw,
                               FieldDefinition fieldDef) {
        FieldVisitor fv = cw.visitField( Opcodes.ACC_PROTECTED,
                                         fieldDef.getName(),
                                         BuildUtils.getTypeDescriptor( fieldDef.getTypeName() ),
                                         null,
                                         null );


        buildFieldAnnotations( fieldDef, fv );

        fv.visitEnd();
    }
667019
def p_scope_identifier(self, p):
        ''
        p[0] = Identifier(p[2], p[1], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
141677
public static Identifier create(String identifier, SourceLocation location) {
    checkArgument(!identifier.isEmpty());
    return new AutoValue_Identifier(identifier, location);
  }
537404
def _set_id_field(new_class):
        """"""
        # FIXME What does it mean when there are no declared fields?
        #   Does it translate to an abstract entity?
        if new_class.meta_.declared_fields:
            try:
                new_class.meta_.id_field = next(
                    field for _, field in new_class.meta_.declared_fields.items()
                    if field.identifier)
            except StopIteration:
                # If no id field is declared then create one
                new_class._create_id_field()
616929
def field(identifier)
      ensure_loaded do
        fields.each do |f|
          return f if f.identifier == identifier
        end
      end
      
      nil
    end
77651
function buildPattern(patternObj, options) {
  const patternFile = { path: patternObj.path };
  return Object.assign(patternObj, {
    name:
      (patternObj.data && patternObj.data.name) ||
      titleCase(resourceKey(patternFile))
  });
}